<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <meta content="en" name="language">
	<title>magick_wand</title>
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
	<link media="screen" href="../docutils-api.css" type="text/css" rel="stylesheet">

</head>

<body>

<div class="banner">
<img src="../images/gm-107x76.png" alt="GraphicMagick logo" width="107" height="76" />
<span class="title">GraphicsMagick</span>
<form action="http://www.google.com/search">
  <input type="hidden" name="domains" value="www.graphicsmagick.org" />
  <input type="hidden" name="sitesearch" value="www.graphicsmagick.org" />
<span class="nowrap"><input type="text" name="q" size="25" maxlength="255" />&nbsp;<input type="submit" name="sa" value="Search" /></span>
</form>
</div>


<div class="navmenu">
<ul>
  <li><a href="../index.html">Home</a></li>
  <li><a href="../project.html">Project</a></li>
  <li><a href="../download.html">Download</a></li>
  <li><a href="../README.html">Install</a></li>
  <li><a href="../Hg.html">Source</a></li>
  <li><a href="../NEWS.html">News</a> </li>
  <li><a href="../utilities.html">Utilities</a></li>
  <li><a href="../programming.html">Programming</a></li>
  <li><a href="../reference.html">Reference</a></li>
</ul>
</div>

<main id="magick-wand">
<h1 class="title">magick_wand</h1>
<p class="subtitle" id="wand-image-processing-interfaces">Wand image processing interfaces</p>
<div class="contents topic" id="contents">
<p class="topic-title">Contents</p>
<ul class="simple">
<li><p><a class="reference internal" href="#clonemagickwand" id="id483">CloneMagickWand</a></p></li>
<li><p><a class="reference internal" href="#destroymagickwand" id="id484">DestroyMagickWand</a></p></li>
<li><p><a class="reference internal" href="#magickadaptivethresholdimage" id="id485">MagickAdaptiveThresholdImage</a></p></li>
<li><p><a class="reference internal" href="#magickaddimage" id="id486">MagickAddImage</a></p></li>
<li><p><a class="reference internal" href="#magickaddnoiseimage" id="id487">MagickAddNoiseImage</a></p></li>
<li><p><a class="reference internal" href="#magickaffinetransformimage" id="id488">MagickAffineTransformImage</a></p></li>
<li><p><a class="reference internal" href="#magickannotateimage" id="id489">MagickAnnotateImage</a></p></li>
<li><p><a class="reference internal" href="#magickanimateimages" id="id490">MagickAnimateImages</a></p></li>
<li><p><a class="reference internal" href="#magickappendimages" id="id491">MagickAppendImages</a></p></li>
<li><p><a class="reference internal" href="#magickautoorientimage" id="id492">MagickAutoOrientImage</a></p></li>
<li><p><a class="reference internal" href="#magickaverageimages" id="id493">MagickAverageImages</a></p></li>
<li><p><a class="reference internal" href="#magickblackthresholdimage" id="id494">MagickBlackThresholdImage</a></p></li>
<li><p><a class="reference internal" href="#magickblurimage" id="id495">MagickBlurImage</a></p></li>
<li><p><a class="reference internal" href="#magickborderimage" id="id496">MagickBorderImage</a></p></li>
<li><p><a class="reference internal" href="#magickcdlimage" id="id497">MagickCdlImage</a></p></li>
<li><p><a class="reference internal" href="#magickcharcoalimage" id="id498">MagickCharcoalImage</a></p></li>
<li><p><a class="reference internal" href="#magickchopimage" id="id499">MagickChopImage</a></p></li>
<li><p><a class="reference internal" href="#magickclearexception" id="id500">MagickClearException</a></p></li>
<li><p><a class="reference internal" href="#magickclipimage" id="id501">MagickClipImage</a></p></li>
<li><p><a class="reference internal" href="#magickclippathimage" id="id502">MagickClipPathImage</a></p></li>
<li><p><a class="reference internal" href="#magickcoalesceimages" id="id503">MagickCoalesceImages</a></p></li>
<li><p><a class="reference internal" href="#magickcolorfloodfillimage" id="id504">MagickColorFloodfillImage</a></p></li>
<li><p><a class="reference internal" href="#magickcolorizeimage" id="id505">MagickColorizeImage</a></p></li>
<li><p><a class="reference internal" href="#magickcommentimage" id="id506">MagickCommentImage</a></p></li>
<li><p><a class="reference internal" href="#magickcompareimagechannels" id="id507">MagickCompareImageChannels</a></p></li>
<li><p><a class="reference internal" href="#magickcompareimages" id="id508">MagickCompareImages</a></p></li>
<li><p><a class="reference internal" href="#magickcompositeimage" id="id509">MagickCompositeImage</a></p></li>
<li><p><a class="reference internal" href="#magickcontrastimage" id="id510">MagickContrastImage</a></p></li>
<li><p><a class="reference internal" href="#magickconvolveimage" id="id511">MagickConvolveImage</a></p></li>
<li><p><a class="reference internal" href="#magickcropimage" id="id512">MagickCropImage</a></p></li>
<li><p><a class="reference internal" href="#magickcyclecolormapimage" id="id513">MagickCycleColormapImage</a></p></li>
<li><p><a class="reference internal" href="#magickdeconstructimages" id="id514">MagickDeconstructImages</a></p></li>
<li><p><a class="reference internal" href="#magickdescribeimage" id="id515">MagickDescribeImage</a></p></li>
<li><p><a class="reference internal" href="#magickdespeckleimage" id="id516">MagickDespeckleImage</a></p></li>
<li><p><a class="reference internal" href="#magickdisplayimage" id="id517">MagickDisplayImage</a></p></li>
<li><p><a class="reference internal" href="#magickdisplayimages" id="id518">MagickDisplayImages</a></p></li>
<li><p><a class="reference internal" href="#magickdrawimage" id="id519">MagickDrawImage</a></p></li>
<li><p><a class="reference internal" href="#magickedgeimage" id="id520">MagickEdgeImage</a></p></li>
<li><p><a class="reference internal" href="#magickembossimage" id="id521">MagickEmbossImage</a></p></li>
<li><p><a class="reference internal" href="#magickenhanceimage" id="id522">MagickEnhanceImage</a></p></li>
<li><p><a class="reference internal" href="#magickequalizeimage" id="id523">MagickEqualizeImage</a></p></li>
<li><p><a class="reference internal" href="#magickextentimage" id="id524">MagickExtentImage</a></p></li>
<li><p><a class="reference internal" href="#magickflattenimages" id="id525">MagickFlattenImages</a></p></li>
<li><p><a class="reference internal" href="#magickflipimage" id="id526">MagickFlipImage</a></p></li>
<li><p><a class="reference internal" href="#magickflopimage" id="id527">MagickFlopImage</a></p></li>
<li><p><a class="reference internal" href="#magickframeimage" id="id528">MagickFrameImage</a></p></li>
<li><p><a class="reference internal" href="#magickfximage" id="id529">MagickFxImage</a></p></li>
<li><p><a class="reference internal" href="#magickfximagechannel" id="id530">MagickFxImageChannel</a></p></li>
<li><p><a class="reference internal" href="#magickgammaimage" id="id531">MagickGammaImage</a></p></li>
<li><p><a class="reference internal" href="#magickgammaimagechannel" id="id532">MagickGammaImageChannel</a></p></li>
<li><p><a class="reference internal" href="#magickgetconfigureinfo" id="id533">MagickGetConfigureInfo</a></p></li>
<li><p><a class="reference internal" href="#magickgetcopyright" id="id534">MagickGetCopyright</a></p></li>
<li><p><a class="reference internal" href="#magickgetexception" id="id535">MagickGetException</a></p></li>
<li><p><a class="reference internal" href="#magickgetfilename" id="id536">MagickGetFilename</a></p></li>
<li><p><a class="reference internal" href="#magickgethomeurl" id="id537">MagickGetHomeURL</a></p></li>
<li><p><a class="reference internal" href="#magickgetimage" id="id538">MagickGetImage</a></p></li>
<li><p><a class="reference internal" href="#magickgetimageattribute" id="id539">MagickGetImageAttribute</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagebackgroundcolor" id="id540">MagickGetImageBackgroundColor</a></p></li>
<li><p><a class="reference internal" href="#magickgetimageblueprimary" id="id541">MagickGetImageBluePrimary</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagebordercolor" id="id542">MagickGetImageBorderColor</a></p></li>
<li><p><a class="reference internal" href="#magickgetimageboundingbox" id="id543">MagickGetImageBoundingBox</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagechanneldepth" id="id544">MagickGetImageChannelDepth</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagechannelextrema" id="id545">MagickGetImageChannelExtrema</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagechannelmean" id="id546">MagickGetImageChannelMean</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagecolormapcolor" id="id547">MagickGetImageColormapColor</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagecolors" id="id548">MagickGetImageColors</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagecolorspace" id="id549">MagickGetImageColorspace</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagecompose" id="id550">MagickGetImageCompose</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagecompression" id="id551">MagickGetImageCompression</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagedelay" id="id552">MagickGetImageDelay</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagedepth" id="id553">MagickGetImageDepth</a></p></li>
<li><p><a class="reference internal" href="#magickgetimageextrema" id="id554">MagickGetImageExtrema</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagedispose" id="id555">MagickGetImageDispose</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagefilename" id="id556">MagickGetImageFilename</a></p></li>
<li><p><a class="reference internal" href="#magickgetimageformat" id="id557">MagickGetImageFormat</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagefuzz" id="id558">MagickGetImageFuzz</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagegamma" id="id559">MagickGetImageGamma</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagegeometry" id="id560">MagickGetImageGeometry</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagegravity" id="id561">MagickGetImageGravity</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagegreenprimary" id="id562">MagickGetImageGreenPrimary</a></p></li>
<li><p><a class="reference internal" href="#magickgetimageheight" id="id563">MagickGetImageHeight</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagehistogram" id="id564">MagickGetImageHistogram</a></p></li>
<li><p><a class="reference internal" href="#magickgetimageindex" id="id565">MagickGetImageIndex</a></p></li>
<li><p><a class="reference internal" href="#magickgetimageinterlacescheme" id="id566">MagickGetImageInterlaceScheme</a></p></li>
<li><p><a class="reference internal" href="#magickgetimageiterations" id="id567">MagickGetImageIterations</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagematte" id="id568">MagickGetImageMatte</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagemattecolor" id="id569">MagickGetImageMatteColor</a></p></li>
<li><p><a class="reference internal" href="#magickgetimageorientation" id="id570">MagickGetImageOrientation</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagepage" id="id571">MagickGetImagePage</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagepixels" id="id572">MagickGetImagePixels</a></p></li>
<li><p><a class="reference internal" href="#magickgetimageprofile" id="id573">MagickGetImageProfile</a></p></li>
<li><p><a class="reference internal" href="#magickgetimageredprimary" id="id574">MagickGetImageRedPrimary</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagerenderingintent" id="id575">MagickGetImageRenderingIntent</a></p></li>
<li><p><a class="reference internal" href="#magickgetimageresolution" id="id576">MagickGetImageResolution</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagescene" id="id577">MagickGetImageScene</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagesignature" id="id578">MagickGetImageSignature</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagesize" id="id579">MagickGetImageSize</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagetype" id="id580">MagickGetImageType</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagesavedtype" id="id581">MagickGetImageSavedType</a></p></li>
<li><p><a class="reference internal" href="#magickgetimageunits" id="id582">MagickGetImageUnits</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagevirtualpixelmethod" id="id583">MagickGetImageVirtualPixelMethod</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagewhitepoint" id="id584">MagickGetImageWhitePoint</a></p></li>
<li><p><a class="reference internal" href="#magickgetimagewidth" id="id585">MagickGetImageWidth</a></p></li>
<li><p><a class="reference internal" href="#magickgetnumberimages" id="id586">MagickGetNumberImages</a></p></li>
<li><p><a class="reference internal" href="#magickgetpackagename" id="id587">MagickGetPackageName</a></p></li>
<li><p><a class="reference internal" href="#magickgetquantumdepth" id="id588">MagickGetQuantumDepth</a></p></li>
<li><p><a class="reference internal" href="#magickgetreleasedate" id="id589">MagickGetReleaseDate</a></p></li>
<li><p><a class="reference internal" href="#magickgetresourcelimit" id="id590">MagickGetResourceLimit</a></p></li>
<li><p><a class="reference internal" href="#magickgetsamplingfactors" id="id591">MagickGetSamplingFactors</a></p></li>
<li><p><a class="reference internal" href="#magickgetsize" id="id592">MagickGetSize</a></p></li>
<li><p><a class="reference internal" href="#magickgetversion" id="id593">MagickGetVersion</a></p></li>
<li><p><a class="reference internal" href="#magickhaldclutimage" id="id594">MagickHaldClutImage</a></p></li>
<li><p><a class="reference internal" href="#magickhascolormap" id="id595">MagickHasColormap</a></p></li>
<li><p><a class="reference internal" href="#magickhasnextimage" id="id596">MagickHasNextImage</a></p></li>
<li><p><a class="reference internal" href="#magickhaspreviousimage" id="id597">MagickHasPreviousImage</a></p></li>
<li><p><a class="reference internal" href="#magickimplodeimage" id="id598">MagickImplodeImage</a></p></li>
<li><p><a class="reference internal" href="#magickisgrayimage" id="id599">MagickIsGrayImage</a></p></li>
<li><p><a class="reference internal" href="#magickismonochromeimage" id="id600">MagickIsMonochromeImage</a></p></li>
<li><p><a class="reference internal" href="#magickisopaqueimage" id="id601">MagickIsOpaqueImage</a></p></li>
<li><p><a class="reference internal" href="#magickispaletteimage" id="id602">MagickIsPaletteImage</a></p></li>
<li><p><a class="reference internal" href="#magicklabelimage" id="id603">MagickLabelImage</a></p></li>
<li><p><a class="reference internal" href="#magicklevelimage" id="id604">MagickLevelImage</a></p></li>
<li><p><a class="reference internal" href="#magicklevelimagechannel" id="id605">MagickLevelImageChannel</a></p></li>
<li><p><a class="reference internal" href="#magickmagnifyimage" id="id606">MagickMagnifyImage</a></p></li>
<li><p><a class="reference internal" href="#magickmapimage" id="id607">MagickMapImage</a></p></li>
<li><p><a class="reference internal" href="#magickmattefloodfillimage" id="id608">MagickMatteFloodfillImage</a></p></li>
<li><p><a class="reference internal" href="#magickmedianfilterimage" id="id609">MagickMedianFilterImage</a></p></li>
<li><p><a class="reference internal" href="#magickminifyimage" id="id610">MagickMinifyImage</a></p></li>
<li><p><a class="reference internal" href="#magickmodulateimage" id="id611">MagickModulateImage</a></p></li>
<li><p><a class="reference internal" href="#magickmontageimage" id="id612">MagickMontageImage</a></p></li>
<li><p><a class="reference internal" href="#magickmorphimages" id="id613">MagickMorphImages</a></p></li>
<li><p><a class="reference internal" href="#magickmosaicimages" id="id614">MagickMosaicImages</a></p></li>
<li><p><a class="reference internal" href="#magickmotionblurimage" id="id615">MagickMotionBlurImage</a></p></li>
<li><p><a class="reference internal" href="#magicknegateimage" id="id616">MagickNegateImage</a></p></li>
<li><p><a class="reference internal" href="#magicknegateimagechannel" id="id617">MagickNegateImageChannel</a></p></li>
<li><p><a class="reference internal" href="#magicknextimage" id="id618">MagickNextImage</a></p></li>
<li><p><a class="reference internal" href="#magicknormalizeimage" id="id619">MagickNormalizeImage</a></p></li>
<li><p><a class="reference internal" href="#magickoilpaintimage" id="id620">MagickOilPaintImage</a></p></li>
<li><p><a class="reference internal" href="#magickopaqueimage" id="id621">MagickOpaqueImage</a></p></li>
<li><p><a class="reference internal" href="#magickoperatorimagechannel" id="id622">MagickOperatorImageChannel</a></p></li>
<li><p><a class="reference internal" href="#magickpingimage" id="id623">MagickPingImage</a></p></li>
<li><p><a class="reference internal" href="#magickpreviewimages" id="id624">MagickPreviewImages</a></p></li>
<li><p><a class="reference internal" href="#magickpreviousimage" id="id625">MagickPreviousImage</a></p></li>
<li><p><a class="reference internal" href="#magickprofileimage" id="id626">MagickProfileImage</a></p></li>
<li><p><a class="reference internal" href="#magickquantizeimage" id="id627">MagickQuantizeImage</a></p></li>
<li><p><a class="reference internal" href="#magickquantizeimages" id="id628">MagickQuantizeImages</a></p></li>
<li><p><a class="reference internal" href="#magickqueryfontmetrics" id="id629">MagickQueryFontMetrics</a></p></li>
<li><p><a class="reference internal" href="#magickqueryfonts" id="id630">MagickQueryFonts</a></p></li>
<li><p><a class="reference internal" href="#magickqueryformats" id="id631">MagickQueryFormats</a></p></li>
<li><p><a class="reference internal" href="#magickradialblurimage" id="id632">MagickRadialBlurImage</a></p></li>
<li><p><a class="reference internal" href="#magickraiseimage" id="id633">MagickRaiseImage</a></p></li>
<li><p><a class="reference internal" href="#magickreadimage" id="id634">MagickReadImage</a></p></li>
<li><p><a class="reference internal" href="#magickreadimageblob" id="id635">MagickReadImageBlob</a></p></li>
<li><p><a class="reference internal" href="#magickreadimagefile" id="id636">MagickReadImageFile</a></p></li>
<li><p><a class="reference internal" href="#magickreducenoiseimage" id="id637">MagickReduceNoiseImage</a></p></li>
<li><p><a class="reference internal" href="#magickrelinquishmemory" id="id638">MagickRelinquishMemory</a></p></li>
<li><p><a class="reference internal" href="#magickremoveimage" id="id639">MagickRemoveImage</a></p></li>
<li><p><a class="reference internal" href="#magickremoveimageoption" id="id640">MagickRemoveImageOption</a></p></li>
<li><p><a class="reference internal" href="#magickremoveimageprofile" id="id641">MagickRemoveImageProfile</a></p></li>
<li><p><a class="reference internal" href="#magickresetiterator" id="id642">MagickResetIterator</a></p></li>
<li><p><a class="reference internal" href="#magickresampleimage" id="id643">MagickResampleImage</a></p></li>
<li><p><a class="reference internal" href="#magickresizeimage" id="id644">MagickResizeImage</a></p></li>
<li><p><a class="reference internal" href="#magickrollimage" id="id645">MagickRollImage</a></p></li>
<li><p><a class="reference internal" href="#magickrotateimage" id="id646">MagickRotateImage</a></p></li>
<li><p><a class="reference internal" href="#magicksampleimage" id="id647">MagickSampleImage</a></p></li>
<li><p><a class="reference internal" href="#magickscaleimage" id="id648">MagickScaleImage</a></p></li>
<li><p><a class="reference internal" href="#magickseparateimagechannel" id="id649">MagickSeparateImageChannel</a></p></li>
<li><p><a class="reference internal" href="#magicksetcompressionquality" id="id650">MagickSetCompressionQuality</a></p></li>
<li><p><a class="reference internal" href="#magicksetdepth" id="id651">MagickSetDepth</a></p></li>
<li><p><a class="reference internal" href="#magicksetfilename" id="id652">MagickSetFilename</a></p></li>
<li><p><a class="reference internal" href="#magicksetformat" id="id653">MagickSetFormat</a></p></li>
<li><p><a class="reference internal" href="#magicksetimage" id="id654">MagickSetImage</a></p></li>
<li><p><a class="reference internal" href="#magicksetimageattribute" id="id655">MagickSetImageAttribute</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagebackgroundcolor" id="id656">MagickSetImageBackgroundColor</a></p></li>
<li><p><a class="reference internal" href="#magicksetimageblueprimary" id="id657">MagickSetImageBluePrimary</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagebordercolor" id="id658">MagickSetImageBorderColor</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagecolormapcolor" id="id659">MagickSetImageColormapColor</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagecolorspace" id="id660">MagickSetImageColorspace</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagecompose" id="id661">MagickSetImageCompose</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagecompression" id="id662">MagickSetImageCompression</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagedelay" id="id663">MagickSetImageDelay</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagechanneldepth" id="id664">MagickSetImageChannelDepth</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagedepth" id="id665">MagickSetImageDepth</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagedispose" id="id666">MagickSetImageDispose</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagefilename" id="id667">MagickSetImageFilename</a></p></li>
<li><p><a class="reference internal" href="#magicksetimageformat" id="id668">MagickSetImageFormat</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagefuzz" id="id669">MagickSetImageFuzz</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagegamma" id="id670">MagickSetImageGamma</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagegeometry" id="id671">MagickSetImageGeometry</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagegravity" id="id672">MagickSetImageGravity</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagegreenprimary" id="id673">MagickSetImageGreenPrimary</a></p></li>
<li><p><a class="reference internal" href="#magicksetimageindex" id="id674">MagickSetImageIndex</a></p></li>
<li><p><a class="reference internal" href="#magicksetimageinterlacescheme" id="id675">MagickSetImageInterlaceScheme</a></p></li>
<li><p><a class="reference internal" href="#magicksetimageiterations" id="id676">MagickSetImageIterations</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagematte" id="id677">MagickSetImageMatte</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagemattecolor" id="id678">MagickSetImageMatteColor</a></p></li>
<li><p><a class="reference internal" href="#magicksetimageoption" id="id679">MagickSetImageOption</a></p></li>
<li><p><a class="reference internal" href="#magicksetimageorientation" id="id680">MagickSetImageOrientation</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagepage" id="id681">MagickSetImagePage</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagepixels" id="id682">MagickSetImagePixels</a></p></li>
<li><p><a class="reference internal" href="#magicksetimageprofile" id="id683">MagickSetImageProfile</a></p></li>
<li><p><a class="reference internal" href="#magicksetimageredprimary" id="id684">MagickSetImageRedPrimary</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagerenderingintent" id="id685">MagickSetImageRenderingIntent</a></p></li>
<li><p><a class="reference internal" href="#magicksetimageresolution" id="id686">MagickSetImageResolution</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagescene" id="id687">MagickSetImageScene</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagetype" id="id688">MagickSetImageType</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagesavedtype" id="id689">MagickSetImageSavedType</a></p></li>
<li><p><a class="reference internal" href="#magicksetimageunits" id="id690">MagickSetImageUnits</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagevirtualpixelmethod" id="id691">MagickSetImageVirtualPixelMethod</a></p></li>
<li><p><a class="reference internal" href="#magicksetinterlacescheme" id="id692">MagickSetInterlaceScheme</a></p></li>
<li><p><a class="reference internal" href="#magicksetresolution" id="id693">MagickSetResolution</a></p></li>
<li><p><a class="reference internal" href="#magicksetresolutionunits" id="id694">MagickSetResolutionUnits</a></p></li>
<li><p><a class="reference internal" href="#magicksetresourcelimit" id="id695">MagickSetResourceLimit</a></p></li>
<li><p><a class="reference internal" href="#magicksetsamplingfactors" id="id696">MagickSetSamplingFactors</a></p></li>
<li><p><a class="reference internal" href="#magicksetsize" id="id697">MagickSetSize</a></p></li>
<li><p><a class="reference internal" href="#magicksetimagewhitepoint" id="id698">MagickSetImageWhitePoint</a></p></li>
<li><p><a class="reference internal" href="#magicksetpassphrase" id="id699">MagickSetPassphrase</a></p></li>
<li><p><a class="reference internal" href="#magicksharpenimage" id="id700">MagickSharpenImage</a></p></li>
<li><p><a class="reference internal" href="#magickshaveimage" id="id701">MagickShaveImage</a></p></li>
<li><p><a class="reference internal" href="#magickshearimage" id="id702">MagickShearImage</a></p></li>
<li><p><a class="reference internal" href="#magicksolarizeimage" id="id703">MagickSolarizeImage</a></p></li>
<li><p><a class="reference internal" href="#magickspreadimage" id="id704">MagickSpreadImage</a></p></li>
<li><p><a class="reference internal" href="#magicksteganoimage" id="id705">MagickSteganoImage</a></p></li>
<li><p><a class="reference internal" href="#magickstereoimage" id="id706">MagickStereoImage</a></p></li>
<li><p><a class="reference internal" href="#magickstripimage" id="id707">MagickStripImage</a></p></li>
<li><p><a class="reference internal" href="#magickswirlimage" id="id708">MagickSwirlImage</a></p></li>
<li><p><a class="reference internal" href="#magicktextureimage" id="id709">MagickTextureImage</a></p></li>
<li><p><a class="reference internal" href="#magickthresholdimage" id="id710">MagickThresholdImage</a></p></li>
<li><p><a class="reference internal" href="#magickthresholdimagechannel" id="id711">MagickThresholdImageChannel</a></p></li>
<li><p><a class="reference internal" href="#magicktintimage" id="id712">MagickTintImage</a></p></li>
<li><p><a class="reference internal" href="#magicktransformimage" id="id713">MagickTransformImage</a></p></li>
<li><p><a class="reference internal" href="#magicktransparentimage" id="id714">MagickTransparentImage</a></p></li>
<li><p><a class="reference internal" href="#magicktrimimage" id="id715">MagickTrimImage</a></p></li>
<li><p><a class="reference internal" href="#magickunsharpmaskimage" id="id716">MagickUnsharpMaskImage</a></p></li>
<li><p><a class="reference internal" href="#magickwaveimage" id="id717">MagickWaveImage</a></p></li>
<li><p><a class="reference internal" href="#magickwhitethresholdimage" id="id718">MagickWhiteThresholdImage</a></p></li>
<li><p><a class="reference internal" href="#magickwriteimage" id="id719">MagickWriteImage</a></p></li>
<li><p><a class="reference internal" href="#magickwriteimagesfile" id="id720">MagickWriteImagesFile</a></p></li>
<li><p><a class="reference internal" href="#magickwriteimageblob" id="id721">MagickWriteImageBlob</a></p></li>
<li><p><a class="reference internal" href="#magickwriteimagefile" id="id722">MagickWriteImageFile</a></p></li>
<li><p><a class="reference internal" href="#magickwriteimages" id="id723">MagickWriteImages</a></p></li>
<li><p><a class="reference internal" href="#newmagickwand" id="id724">NewMagickWand</a></p></li>
</ul>
</div>
<section id="clonemagickwand">
<h1><a class="toc-backref" href="#id483">CloneMagickWand</a></h1>
<section id="synopsis">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand *CloneMagickWand( const MagickWand *wand );</pre>
</section>
<section id="description">
<h2>Description</h2>
<p>CloneMagickWand() makes an exact copy of the specified wand.</p>
<p>The format of the CloneMagickWand method is:</p>
<pre class="literal-block">MagickWand *CloneMagickWand( const MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand to clone.</p>
</dd>
</dl>
</section>
</section>
<section id="destroymagickwand">
<h1><a class="toc-backref" href="#id484">DestroyMagickWand</a></h1>
<section id="id1">
<h2>Synopsis</h2>
<pre class="literal-block">void DestroyMagickWand( MagickWand *wand );</pre>
</section>
<section id="id2">
<h2>Description</h2>
<p>DestroyMagickWand() deallocates memory associated with an MagickWand.</p>
<p>The format of the DestroyMagickWand method is:</p>
<pre class="literal-block">void DestroyMagickWand( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickadaptivethresholdimage">
<h1><a class="toc-backref" href="#id485">MagickAdaptiveThresholdImage</a></h1>
<section id="id3">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickAdaptiveThresholdImage( MagickWand *wand, const unsigned long width,
                                           const unsigned long height, const long offset );</pre>
</section>
<section id="id4">
<h2>Description</h2>
<p>MagickAdaptiveThresholdImage() selects an individual threshold for each pixel
based on the range of intensity values in its local neighborhood.  This
allows for thresholding of an image whose global intensity histogram
doesn't contain distinctive peaks.</p>
<p>The format of the MagickAdaptiveThresholdImage method is:</p>
<pre class="literal-block">unsigned int MagickAdaptiveThresholdImage( MagickWand *wand, const unsigned long width,
                                           const unsigned long height, const long offset );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>width:</dt>
<dd><p>The width of the local neighborhood.</p>
</dd>
<dt>height:</dt>
<dd><p>The height of the local neighborhood.</p>
</dd>
<dt>offset:</dt>
<dd><p>The mean offset.</p>
</dd>
</dl>
</section>
</section>
<section id="magickaddimage">
<h1><a class="toc-backref" href="#id486">MagickAddImage</a></h1>
<section id="id5">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickAddImage( MagickWand *wand, const MagickWand *add_wand );</pre>
</section>
<section id="id6">
<h2>Description</h2>
<p>MagickAddImage() adds the specified images at the current image location.</p>
<p>The format of the MagickAddImage method is:</p>
<pre class="literal-block">unsigned int MagickAddImage( MagickWand *wand, const MagickWand *add_wand );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>insert:</dt>
<dd><p>The splice wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickaddnoiseimage">
<h1><a class="toc-backref" href="#id487">MagickAddNoiseImage</a></h1>
<section id="id7">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickAddNoiseImage( MagickWand *wand, const <a class="reference external" href="../api/types.html#noisetype">NoiseType</a> noise_type );</pre>
</section>
<section id="id8">
<h2>Description</h2>
<p>MagickAddNoiseImage() adds random noise to the image.</p>
<p>The format of the MagickAddNoiseImage method is:</p>
<pre class="literal-block">unsigned int MagickAddNoiseImage( MagickWand *wand, const <a class="reference external" href="../api/types.html#noisetype">NoiseType</a> noise_type );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>noise_type:</dt>
<dd><p>The type of noise: Uniform, Gaussian, Multiplicative,
Impulse, Laplacian, Poisson, or Random.</p>
</dd>
</dl>
</section>
</section>
<section id="magickaffinetransformimage">
<h1><a class="toc-backref" href="#id488">MagickAffineTransformImage</a></h1>
<section id="id9">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickAffineTransformImage( MagickWand *wand, const DrawingWand *drawing_wand );</pre>
</section>
<section id="id10">
<h2>Description</h2>
<p>MagickAffineTransformImage() transforms an image as dictated by the affine
matrix of the drawing wand.</p>
<p>The format of the MagickAffineTransformImage method is:</p>
<pre class="literal-block">unsigned int MagickAffineTransformImage( MagickWand *wand, const DrawingWand *drawing_wand );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>drawing_wand:</dt>
<dd><p>The draw wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickannotateimage">
<h1><a class="toc-backref" href="#id489">MagickAnnotateImage</a></h1>
<section id="id11">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickAnnotateImage( MagickWand *wand, const DrawingWand *drawing_wand,
                                  const double x, const double y, const double angle,
                                  const char *text );</pre>
</section>
<section id="id12">
<h2>Description</h2>
<p>MagickAnnotateImage() annotates an image with text.</p>
<p>The format of the MagickAnnotateImage method is:</p>
<pre class="literal-block">unsigned int MagickAnnotateImage( MagickWand *wand, const DrawingWand *drawing_wand,
                                  const double x, const double y, const double angle,
                                  const char *text );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>drawing_wand:</dt>
<dd><p>The draw wand.</p>
</dd>
<dt>x:</dt>
<dd><p>x ordinate to left of text</p>
</dd>
<dt>y:</dt>
<dd><p>y ordinate to text baseline</p>
</dd>
<dt>angle:</dt>
<dd><p>rotate text relative to this angle.</p>
</dd>
<dt>text:</dt>
<dd><p>text to draw</p>
</dd>
</dl>
</section>
</section>
<section id="magickanimateimages">
<h1><a class="toc-backref" href="#id490">MagickAnimateImages</a></h1>
<section id="id13">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickAnimateImages( MagickWand *wand, const char *server_name );</pre>
</section>
<section id="id14">
<h2>Description</h2>
<p>MagickAnimateImages() animates an image or image sequence.</p>
<p>The format of the MagickAnimateImages method is:</p>
<pre class="literal-block">unsigned int MagickAnimateImages( MagickWand *wand, const char *server_name );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>server_name:</dt>
<dd><p>The X server name.</p>
</dd>
</dl>
</section>
</section>
<section id="magickappendimages">
<h1><a class="toc-backref" href="#id491">MagickAppendImages</a></h1>
<section id="id15">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand *MagickAppendImages( MagickWand *wand, const unsigned int stack );</pre>
</section>
<section id="id16">
<h2>Description</h2>
<p>MagickAppendImages() append a set of images.</p>
<p>The format of the MagickAppendImages method is:</p>
<pre class="literal-block">MagickWand *MagickAppendImages( MagickWand *wand, const unsigned int stack );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>stack:</dt>
<dd><p>By default, images are stacked left-to-right. Set stack to True
to stack them top-to-bottom.</p>
</dd>
</dl>
</section>
</section>
<section id="magickautoorientimage">
<h1><a class="toc-backref" href="#id492">MagickAutoOrientImage</a></h1>
<section id="id17">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickAutoOrientImage( MagickWand *wand,
                                    const OrientationType current_orientation,
                                    <a class="reference external" href="../api/types.html#exceptioninfo">ExceptionInfo</a> *exception );</pre>
</section>
<section id="id18">
<h2>Description</h2>
<p>MagickAutoOrientImage() adjusts the current image so that its orientation
is suitable for viewing (i.e. top-left orientation).</p>
<p>The format of the MagickAutoOrientImage method is:</p>
<pre class="literal-block">unsigned int MagickAutoOrientImage( MagickWand *wand,
                                    const OrientationType current_orientation,
                                    <a class="reference external" href="../api/types.html#exceptioninfo">ExceptionInfo</a> *exception );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>current_orientation:</dt>
<dd><p>Current image orientation. May be one of:
TopLeftOrientation      Left to right and Top to bottom
TopRightOrientation     Right to left  and Top to bottom
BottomRightOrientation  Right to left and Bottom to top
BottomLeftOrientation   Left to right and Bottom to top
LeftTopOrientation      Top to bottom and Left to right
RightTopOrientation     Top to bottom and Right to left
RightBottomOrientation  Bottom to top and Right to left
LeftBottomOrientation   Bottom to top and Left to right
UndefinedOrientation    Current orientation is not known.
Use orientation defined by the
current image if any. Equivalent
to MagickGetImageOrientation().</p>
</dd>
</dl>
<p>Returns True on success, False otherwise.</p>
<p>Note that after successful auto-orientation the internal orientation will
be set to TopLeftOrientation. However this internal value is only written
to TIFF files. For JPEG files, there is currently no support for resetting
the EXIF orientation tag to TopLeft so the JPEG should be stripped or EXIF
profile removed if present to prevent saved auto-oriented images from being
incorrectly rotated a second time by follow-on viewers that understand the
EXIF orientation tag.</p>
</section>
</section>
<section id="magickaverageimages">
<h1><a class="toc-backref" href="#id493">MagickAverageImages</a></h1>
<section id="id19">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand *MagickAverageImages( MagickWand *wand );</pre>
</section>
<section id="id20">
<h2>Description</h2>
<p>MagickAverageImages() average a set of images.</p>
<p>The format of the MagickAverageImages method is:</p>
<pre class="literal-block">MagickWand *MagickAverageImages( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickblackthresholdimage">
<h1><a class="toc-backref" href="#id494">MagickBlackThresholdImage</a></h1>
<section id="id21">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickBlackThresholdImage( MagickWand *wand, const PixelWand *threshold );</pre>
</section>
<section id="id22">
<h2>Description</h2>
<p>MagickBlackThresholdImage() is like MagickThresholdImage() but  forces all
pixels below the threshold into black while leaving all pixels above the
threshold unchanged.</p>
<p>The format of the MagickBlackThresholdImage method is:</p>
<pre class="literal-block">unsigned int MagickBlackThresholdImage( MagickWand *wand, const PixelWand *threshold );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>threshold:</dt>
<dd><p>The pixel wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickblurimage">
<h1><a class="toc-backref" href="#id495">MagickBlurImage</a></h1>
<section id="id23">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickBlurImage( MagickWand *wand, const double radius, const double sigma );</pre>
</section>
<section id="id24">
<h2>Description</h2>
<p>MagickBlurImage() blurs an image.  We convolve the image with a Gaussian
operator of the given radius and standard deviation (sigma).
For reasonable results, the radius should be larger than sigma.  Use a
radius of 0 and BlurImage() selects a suitable radius for you.</p>
<p>The format of the MagickBlurImage method is:</p>
<pre class="literal-block">unsigned int MagickBlurImage( MagickWand *wand, const double radius, const double sigma );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>radius:</dt>
<dd><p>The radius of the Gaussian, in pixels, not counting the center
pixel.</p>
</dd>
<dt>sigma:</dt>
<dd><p>The standard deviation of the Gaussian, in pixels.</p>
</dd>
</dl>
</section>
</section>
<section id="magickborderimage">
<h1><a class="toc-backref" href="#id496">MagickBorderImage</a></h1>
<section id="id25">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickBorderImage( MagickWand *wand, const PixelWand *bordercolor,
                                const unsigned long width, const unsigned long height );</pre>
</section>
<section id="id26">
<h2>Description</h2>
<p>MagickBorderImage() surrounds the image with a border of the color defined
by the bordercolor pixel wand.</p>
<p>The format of the MagickBorderImage method is:</p>
<pre class="literal-block">unsigned int MagickBorderImage( MagickWand *wand, const PixelWand *bordercolor,
                                const unsigned long width, const unsigned long height );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>bordercolor:</dt>
<dd><p>The border color pixel wand.</p>
</dd>
<dt>width:</dt>
<dd><p>The border width.</p>
</dd>
<dt>height:</dt>
<dd><p>The border height.</p>
</dd>
</dl>
</section>
</section>
<section id="magickcdlimage">
<h1><a class="toc-backref" href="#id497">MagickCdlImage</a></h1>
<section id="id27">
<h2>Synopsis</h2>
<pre class="literal-block">MagickPassFail MagickCdlImage( MagickWand *wand, const char *cdl );</pre>
</section>
<section id="id28">
<h2>Description</h2>
<p>The MagickCdlImage() method applies (&quot;bakes in&quot;) the ASC-CDL which is a
format for the exchange of basic primary color grading information between
equipment and software from different manufacturers. The format defines
the math for three functions: slope, offset and power. Each function uses
a number for the red, green, and blue color channels for a total of nine
numbers comprising a single color decision. A tenth number for chrominance
(saturation) has been proposed but is not yet standardized.</p>
<p>The cdl argument string is comma delimited and is in the form (but
without invervening spaces or line breaks):</p>
<p>redslope, redoffset, redpower :
greenslope, greenoffset, greenpower :
blueslope, blueoffset, bluepower :
saturation</p>
<p>with the unity (no change) specification being:</p>
<p>&quot;1.0,0.0,1.0:1.0,0.0,1.0:1.0,0.0,1.0:0.0&quot;</p>
<p>See <a class="reference external" href="http://en.wikipedia.org/wiki/ASC_CDL">http://en.wikipedia.org/wiki/ASC_CDL</a> for more information.</p>
<p>The format of the MagickCdlImage method is:</p>
<pre class="literal-block">MagickPassFail MagickCdlImage( MagickWand *wand, const char *cdl );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The image wand.</p>
</dd>
<dt>cdl:</dt>
<dd><p>Define the coefficients for slope offset and power in the
red green and blue channels, plus saturation.</p>
</dd>
</dl>
</section>
</section>
<section id="magickcharcoalimage">
<h1><a class="toc-backref" href="#id498">MagickCharcoalImage</a></h1>
<section id="id29">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickCharcoalImage( MagickWand *wand, const double radius, const double sigma );</pre>
</section>
<section id="id30">
<h2>Description</h2>
<p>MagickCharcoalImage() simulates a charcoal drawing.</p>
<p>The format of the MagickCharcoalImage method is:</p>
<pre class="literal-block">unsigned int MagickCharcoalImage( MagickWand *wand, const double radius, const double sigma );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>radius:</dt>
<dd><p>The radius of the Gaussian, in pixels, not counting the center
pixel.</p>
</dd>
<dt>sigma:</dt>
<dd><p>The standard deviation of the Gaussian, in pixels.</p>
</dd>
</dl>
</section>
</section>
<section id="magickchopimage">
<h1><a class="toc-backref" href="#id499">MagickChopImage</a></h1>
<section id="id31">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickChopImage( MagickWand *wand, const unsigned long width,
                              const unsigned long height, const long x, const long y );</pre>
</section>
<section id="id32">
<h2>Description</h2>
<p>MagickChopImage() removes a region of an image and collapses the image to
occupy the removed portion</p>
<p>The format of the MagickChopImage method is:</p>
<pre class="literal-block">unsigned int MagickChopImage( MagickWand *wand, const unsigned long width,
                              const unsigned long height, const long x, const long y );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>width:</dt>
<dd><p>The region width.</p>
</dd>
<dt>height:</dt>
<dd><p>The region height.</p>
</dd>
<dt>x:</dt>
<dd><p>The region x offset.</p>
</dd>
<dt>y:</dt>
<dd><p>The region y offset.</p>
</dd>
</dl>
</section>
</section>
<section id="magickclearexception">
<h1><a class="toc-backref" href="#id500">MagickClearException</a></h1>
<section id="id33">
<h2>Synopsis</h2>
<pre class="literal-block">void MagickClearException( MagickWand *wand );</pre>
</section>
<section id="id34">
<h2>Description</h2>
<p>MagickClearException() clears the last wand exception.</p>
<p>The format of the MagickClearException method is:</p>
<pre class="literal-block">void MagickClearException( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickclipimage">
<h1><a class="toc-backref" href="#id501">MagickClipImage</a></h1>
<section id="id35">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickClipImage( MagickWand *wand );</pre>
</section>
<section id="id36">
<h2>Description</h2>
<p>MagickClipImage() clips along the first path from the 8BIM profile, if
present.</p>
<p>The format of the MagickClipImage method is:</p>
<pre class="literal-block">unsigned int MagickClipImage( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickclippathimage">
<h1><a class="toc-backref" href="#id502">MagickClipPathImage</a></h1>
<section id="id37">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickClipPathImage( MagickWand *wand, const char *pathname,
                                  const unsigned int inside );</pre>
</section>
<section id="id38">
<h2>Description</h2>
<p>MagickClipPathImage() clips along the named paths from the 8BIM profile, if
present. Later operations take effect inside the path.  Id may be a number
if preceded with #, to work on a numbered path, e.g., &quot;#1&quot; to use the first
path.</p>
<p>The format of the MagickClipPathImage method is:</p>
<pre class="literal-block">unsigned int MagickClipPathImage( MagickWand *wand, const char *pathname,
                                  const unsigned int inside );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>pathname:</dt>
<dd><p>name of clipping path resource. If name is preceded by #, use
clipping path numbered by name.</p>
</dd>
<dt>inside:</dt>
<dd><p>if non-zero, later operations take effect inside clipping path.
Otherwise later operations take effect outside clipping path.</p>
</dd>
</dl>
</section>
</section>
<section id="magickcoalesceimages">
<h1><a class="toc-backref" href="#id503">MagickCoalesceImages</a></h1>
<section id="id39">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand *MagickCoalesceImages( MagickWand *wand );</pre>
</section>
<section id="id40">
<h2>Description</h2>
<p>MagickCoalesceImages() composites a set of images while respecting any page
offsets and disposal methods.  GIF, MIFF, and MNG animation sequences
typically start with an image background and each subsequent image
varies in size and offset.  MagickCoalesceImages() returns a new sequence
where each image in the sequence is the same size as the first and
composited with the next image in the sequence.</p>
<p>The format of the MagickCoalesceImages method is:</p>
<pre class="literal-block">MagickWand *MagickCoalesceImages( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickcolorfloodfillimage">
<h1><a class="toc-backref" href="#id504">MagickColorFloodfillImage</a></h1>
<section id="id41">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickColorFloodfillImage( MagickWand *wand, const PixelWand *fill,
                                        const double fuzz, const PixelWand *bordercolor,
                                        const long x, const long y );</pre>
</section>
<section id="id42">
<h2>Description</h2>
<p>MagickColorFloodfillImage() changes the color value of any pixel that matches
target and is an immediate neighbor.  If the method FillToBorderMethod is
specified, the color value is changed for any neighbor pixel that does not
match the bordercolor member of image.</p>
<p>The format of the MagickColorFloodfillImage method is:</p>
<pre class="literal-block">unsigned int MagickColorFloodfillImage( MagickWand *wand, const PixelWand *fill,
                                        const double fuzz, const PixelWand *bordercolor,
                                        const long x, const long y );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>fill:</dt>
<dd><p>The floodfill color pixel wand.</p>
</dd>
<dt>fuzz:</dt>
<dd><p>By default target must match a particular pixel color
exactly.  However, in many cases two colors may differ by a small amount.
The fuzz member of image defines how much tolerance is acceptable to
consider two colors as the same.  For example, set fuzz to 10 and the
color red at intensities of 100 and 102 respectively are now interpreted
as the same color for the purposes of the floodfill.</p>
</dd>
<dt>bordercolor:</dt>
<dd><p>The border color pixel wand.</p>
</dd>
<dt>x,y:</dt>
<dd><p>The starting location of the operation.</p>
</dd>
</dl>
</section>
</section>
<section id="magickcolorizeimage">
<h1><a class="toc-backref" href="#id505">MagickColorizeImage</a></h1>
<section id="id43">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickColorizeImage( MagickWand *wand, const PixelWand *colorize,
                                  const PixelWand *opacity );</pre>
</section>
<section id="id44">
<h2>Description</h2>
<p>MagickColorizeImage() blends the fill color with each pixel in the image.</p>
<p>The format of the MagickColorizeImage method is:</p>
<pre class="literal-block">unsigned int MagickColorizeImage( MagickWand *wand, const PixelWand *colorize,
                                  const PixelWand *opacity );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>colorize:</dt>
<dd><p>The colorize pixel wand.</p>
</dd>
<dt>opacity:</dt>
<dd><p>The opacity pixel wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickcommentimage">
<h1><a class="toc-backref" href="#id506">MagickCommentImage</a></h1>
<section id="id45">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickCommentImage( MagickWand *wand, const char *comment );</pre>
</section>
<section id="id46">
<h2>Description</h2>
<p>MagickCommentImage() adds a comment to your image.</p>
<p>The format of the MagickCommentImage method is:</p>
<pre class="literal-block">unsigned int MagickCommentImage( MagickWand *wand, const char *comment );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>comment:</dt>
<dd><p>The image comment.</p>
</dd>
</dl>
</section>
</section>
<section id="magickcompareimagechannels">
<h1><a class="toc-backref" href="#id507">MagickCompareImageChannels</a></h1>
<section id="id47">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand *MagickCompareImageChannels( MagickWand *wand, const MagickWand *reference,
                                        const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel, const MetricType metric,
                                        double *distortion );</pre>
</section>
<section id="id48">
<h2>Description</h2>
<p>MagickCompareImageChannels() compares one or more image channels and
returns the specified distortion metric.</p>
<p>The format of the MagickCompareImageChannels method is:</p>
<pre class="literal-block">MagickWand *MagickCompareImageChannels( MagickWand *wand, const MagickWand *reference,
                                        const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel, const MetricType metric,
                                        double *distortion );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>reference:</dt>
<dd><p>The reference wand.</p>
</dd>
<dt>channel:</dt>
<dd><p>The channel.</p>
</dd>
<dt>metric:</dt>
<dd><p>The metric.</p>
</dd>
<dt>distortion:</dt>
<dd><p>The computed distortion between the images.</p>
</dd>
</dl>
</section>
</section>
<section id="magickcompareimages">
<h1><a class="toc-backref" href="#id508">MagickCompareImages</a></h1>
<section id="id49">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand *MagickCompareImages( MagickWand *wand, const MagickWand *reference,
                                 const MetricType metric, double *distortion );</pre>
</section>
<section id="id50">
<h2>Description</h2>
<p>MagickCompareImage() compares one or more images and returns the specified
distortion metric.</p>
<p>The format of the MagickCompareImages method is:</p>
<pre class="literal-block">MagickWand *MagickCompareImages( MagickWand *wand, const MagickWand *reference,
                                 const MetricType metric, double *distortion );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>reference:</dt>
<dd><p>The reference wand.</p>
</dd>
<dt>metric:</dt>
<dd><p>The metric.</p>
</dd>
<dt>distortion:</dt>
<dd><p>The computed distortion between the images.</p>
</dd>
</dl>
</section>
</section>
<section id="magickcompositeimage">
<h1><a class="toc-backref" href="#id509">MagickCompositeImage</a></h1>
<section id="id51">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickCompositeImage( MagickWand *wand, const MagickWand *composite_wand,
                                   const <a class="reference external" href="../api/types.html#compositeoperator">CompositeOperator</a> compose, const long x,
                                   const long y );</pre>
</section>
<section id="id52">
<h2>Description</h2>
<p>MagickCompositeImage() composite one image onto another at the specified
offset.</p>
<p>The format of the MagickCompositeImage method is:</p>
<pre class="literal-block">unsigned int MagickCompositeImage( MagickWand *wand, const MagickWand *composite_wand,
                                   const <a class="reference external" href="../api/types.html#compositeoperator">CompositeOperator</a> compose, const long x,
                                   const long y );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>composite_image:</dt>
<dd><p>The composite image.</p>
</dd>
<dt>compose:</dt>
<dd><p>This operator affects how the composite is applied to the
image.  The default is Over.  Choose from these operators:</p>
</dd>
</dl>
<p>OverCompositeOp       InCompositeOp         OutCompositeOP
AtopCompositeOP       XorCompositeOP        PlusCompositeOP
MinusCompositeOP      AddCompositeOP        SubtractCompositeOP
DifferenceCompositeOP BumpmapCompositeOP    CopyCompositeOP
DisplaceCompositeOP</p>
<dl class="simple">
<dt>x_offset:</dt>
<dd><p>The column offset of the composited image.</p>
</dd>
<dt>y_offset:</dt>
<dd><p>The row offset of the composited image.</p>
</dd>
</dl>
</section>
</section>
<section id="magickcontrastimage">
<h1><a class="toc-backref" href="#id510">MagickContrastImage</a></h1>
<section id="id53">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickContrastImage( MagickWand *wand, const unsigned int sharpen );</pre>
</section>
<section id="id54">
<h2>Description</h2>
<p>MagickContrastImage() enhances the intensity differences between the lighter
and darker elements of the image.  Set sharpen to a value other than 0 to
increase the image contrast otherwise the contrast is reduced.</p>
<p>The format of the MagickContrastImage method is:</p>
<pre class="literal-block">unsigned int MagickContrastImage( MagickWand *wand, const unsigned int sharpen );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>sharpen:</dt>
<dd><p>Increase or decrease image contrast.</p>
</dd>
</dl>
</section>
</section>
<section id="magickconvolveimage">
<h1><a class="toc-backref" href="#id511">MagickConvolveImage</a></h1>
<section id="id55">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickConvolveImage( MagickWand *wand, const unsigned long order,
                                  const double *kernel );</pre>
</section>
<section id="id56">
<h2>Description</h2>
<p>MagickConvolveImage() applies a custom convolution kernel to the image.</p>
<p>The format of the MagickConvolveImage method is:</p>
<pre class="literal-block">unsigned int MagickConvolveImage( MagickWand *wand, const unsigned long order,
                                  const double *kernel );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>order:</dt>
<dd><p>The number of columns and rows in the filter kernel.</p>
</dd>
<dt>kernel:</dt>
<dd><p>An array of doubles representing the convolution kernel.</p>
</dd>
</dl>
</section>
</section>
<section id="magickcropimage">
<h1><a class="toc-backref" href="#id512">MagickCropImage</a></h1>
<section id="id57">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickCropImage( MagickWand *wand, const unsigned long width,
                              const unsigned long height, const long x, const long y );</pre>
</section>
<section id="id58">
<h2>Description</h2>
<p>MagickCropImage() extracts a region of the image.</p>
<p>The format of the MagickCropImage method is:</p>
<pre class="literal-block">unsigned int MagickCropImage( MagickWand *wand, const unsigned long width,
                              const unsigned long height, const long x, const long y );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>width:</dt>
<dd><p>The region width.</p>
</dd>
<dt>height:</dt>
<dd><p>The region height.</p>
</dd>
<dt>x:</dt>
<dd><p>The region x offset.</p>
</dd>
<dt>y:</dt>
<dd><p>The region y offset.</p>
</dd>
</dl>
</section>
</section>
<section id="magickcyclecolormapimage">
<h1><a class="toc-backref" href="#id513">MagickCycleColormapImage</a></h1>
<section id="id59">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickCycleColormapImage( MagickWand *wand, const long displace );</pre>
</section>
<section id="id60">
<h2>Description</h2>
<p>MagickCycleColormapImage() displaces an image's colormap by a given number
of positions.  If you cycle the colormap a number of times you can produce
a psychodelic effect.</p>
<p>The format of the MagickCycleColormapImage method is:</p>
<pre class="literal-block">unsigned int MagickCycleColormapImage( MagickWand *wand, const long displace );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>pixel_wand:</dt>
<dd><p>The pixel wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickdeconstructimages">
<h1><a class="toc-backref" href="#id514">MagickDeconstructImages</a></h1>
<section id="id61">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand *MagickDeconstructImages( MagickWand *wand );</pre>
</section>
<section id="id62">
<h2>Description</h2>
<p>MagickDeconstructImages() compares each image with the next in a sequence
and returns the maximum bounding region of any pixel differences it
discovers.</p>
<p>The format of the MagickDeconstructImages method is:</p>
<pre class="literal-block">MagickWand *MagickDeconstructImages( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickdescribeimage">
<h1><a class="toc-backref" href="#id515">MagickDescribeImage</a></h1>
<section id="id63">
<h2>Synopsis</h2>
<pre class="literal-block">const char *MagickDescribeImage( MagickWand *wand );</pre>
</section>
<section id="id64">
<h2>Description</h2>
<p>MagickDescribeImage()  describes an image by formatting its attributes
to an allocated string which must be freed by the user.  Attributes
include the image width, height, size, and others.  The string is
similar to the output of 'identify -verbose'.</p>
<p>The format of the MagickDescribeImage method is:</p>
<pre class="literal-block">const char *MagickDescribeImage( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickdespeckleimage">
<h1><a class="toc-backref" href="#id516">MagickDespeckleImage</a></h1>
<section id="id65">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickDespeckleImage( MagickWand *wand );</pre>
</section>
<section id="id66">
<h2>Description</h2>
<p>MagickDespeckleImage() reduces the speckle noise in an image while
perserving the edges of the original image.</p>
<p>The format of the MagickDespeckleImage method is:</p>
<pre class="literal-block">unsigned int MagickDespeckleImage( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickdisplayimage">
<h1><a class="toc-backref" href="#id517">MagickDisplayImage</a></h1>
<section id="id67">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickDisplayImage( MagickWand *wand, const char *server_name );</pre>
</section>
<section id="id68">
<h2>Description</h2>
<p>MagickDisplayImage() displays an image.</p>
<p>The format of the MagickDisplayImage method is:</p>
<pre class="literal-block">unsigned int MagickDisplayImage( MagickWand *wand, const char *server_name );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>server_name:</dt>
<dd><p>The X server name.</p>
</dd>
</dl>
</section>
</section>
<section id="magickdisplayimages">
<h1><a class="toc-backref" href="#id518">MagickDisplayImages</a></h1>
<section id="id69">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickDisplayImages( MagickWand *wand, const char *server_name );</pre>
</section>
<section id="id70">
<h2>Description</h2>
<p>MagickDisplayImages() displays an image or image sequence.</p>
<p>The format of the MagickDisplayImages method is:</p>
<pre class="literal-block">unsigned int MagickDisplayImages( MagickWand *wand, const char *server_name );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>server_name:</dt>
<dd><p>The X server name.</p>
</dd>
</dl>
</section>
</section>
<section id="magickdrawimage">
<h1><a class="toc-backref" href="#id519">MagickDrawImage</a></h1>
<section id="id71">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickDrawImage( MagickWand *wand, const DrawingWand *drawing_wand );</pre>
</section>
<section id="id72">
<h2>Description</h2>
<p>MagickDrawImage() draws vectors on the image as described by DrawingWand.</p>
<p>The format of the MagickDrawImage method is:</p>
<pre class="literal-block">unsigned int MagickDrawImage( MagickWand *wand, const DrawingWand *drawing_wand );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>drawing_wand:</dt>
<dd><p>The draw wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickedgeimage">
<h1><a class="toc-backref" href="#id520">MagickEdgeImage</a></h1>
<section id="id73">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickEdgeImage( MagickWand *wand, const double radius );</pre>
</section>
<section id="id74">
<h2>Description</h2>
<p>MagickEdgeImage() enhance edges within the image with a convolution filter
of the given radius.  Use a radius of 0 and Edge() selects a suitable
radius for you.</p>
<p>The format of the MagickEdgeImage method is:</p>
<pre class="literal-block">unsigned int MagickEdgeImage( MagickWand *wand, const double radius );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>radius:</dt>
<dd><p>the radius of the pixel neighborhood.</p>
</dd>
</dl>
</section>
</section>
<section id="magickembossimage">
<h1><a class="toc-backref" href="#id521">MagickEmbossImage</a></h1>
<section id="id75">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickEmbossImage( MagickWand *wand, const double radius, const double sigma );</pre>
</section>
<section id="id76">
<h2>Description</h2>
<p>MagickEmbossImage() returns a grayscale image with a three-dimensional
effect.  We convolve the image with a Gaussian operator of the given radius
and standard deviation (sigma).  For reasonable results, radius should be
larger than sigma.  Use a radius of 0 and Emboss() selects a suitable
radius for you.</p>
<p>The format of the MagickEmbossImage method is:</p>
<pre class="literal-block">unsigned int MagickEmbossImage( MagickWand *wand, const double radius, const double sigma );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>radius:</dt>
<dd><p>The radius of the Gaussian, in pixels, not counting the center
pixel.</p>
</dd>
<dt>sigma:</dt>
<dd><p>The standard deviation of the Gaussian, in pixels.</p>
</dd>
</dl>
</section>
</section>
<section id="magickenhanceimage">
<h1><a class="toc-backref" href="#id522">MagickEnhanceImage</a></h1>
<section id="id77">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickEnhanceImage( MagickWand *wand );</pre>
</section>
<section id="id78">
<h2>Description</h2>
<p>MagickEnhanceImage() applies a digital filter that improves the quality of a
noisy image.</p>
<p>The format of the MagickEnhanceImage method is:</p>
<pre class="literal-block">unsigned int MagickEnhanceImage( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickequalizeimage">
<h1><a class="toc-backref" href="#id523">MagickEqualizeImage</a></h1>
<section id="id79">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickEqualizeImage( MagickWand *wand );</pre>
</section>
<section id="id80">
<h2>Description</h2>
<p>MagickEqualizeImage() equalizes the image histogram.</p>
<p>The format of the MagickEqualizeImage method is:</p>
<pre class="literal-block">unsigned int MagickEqualizeImage( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickextentimage">
<h1><a class="toc-backref" href="#id524">MagickExtentImage</a></h1>
<section id="id81">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickExtentImage( MagickWand *wand, const size_t width, const size_t height,
                                const ssize_t x, const ssize_t y );</pre>
</section>
<section id="id82">
<h2>Description</h2>
<p>Use MagickExtentImage() to change the image dimensions as specified by
geometry width and height.  The existing image content is composited at
the position specified by geometry x and y using the image compose method.
Existing image content which falls outside the bounds of the new image
dimensions is discarded.</p>
<p>The format of the MagickExtentImage method is:</p>
<pre class="literal-block">unsigned int MagickExtentImage( MagickWand *wand, const size_t width, const size_t height,
                                const ssize_t x, const ssize_t y );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>width:</dt>
<dd><p>New image width</p>
</dd>
<dt>height:</dt>
<dd><p>New image height</p>
</dd>
<dt>x, y:</dt>
<dd><p>Top left composition coordinate to place existing image content
on the new image.</p>
</dd>
</dl>
</section>
</section>
<section id="magickflattenimages">
<h1><a class="toc-backref" href="#id525">MagickFlattenImages</a></h1>
<section id="id83">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand *MagickFlattenImages( MagickWand *wand );</pre>
</section>
<section id="id84">
<h2>Description</h2>
<p>MagickFlattenImages() merges a sequence of images.  This is useful for
combining Photoshop layers into a single image.</p>
<p>The format of the MagickFlattenImages method is:</p>
<pre class="literal-block">MagickWand *MagickFlattenImages( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickflipimage">
<h1><a class="toc-backref" href="#id526">MagickFlipImage</a></h1>
<section id="id85">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickFlipImage( MagickWand *wand );</pre>
</section>
<section id="id86">
<h2>Description</h2>
<p>MagickFlipImage() creates a vertical mirror image by reflecting the pixels
around the central x-axis.</p>
<p>The format of the MagickFlipImage method is:</p>
<pre class="literal-block">unsigned int MagickFlipImage( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickflopimage">
<h1><a class="toc-backref" href="#id527">MagickFlopImage</a></h1>
<section id="id87">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickFlopImage( MagickWand *wand );</pre>
</section>
<section id="id88">
<h2>Description</h2>
<p>MagickFlopImage() creates a horizontal mirror image by reflecting the pixels
around the central y-axis.</p>
<p>The format of the MagickFlopImage method is:</p>
<pre class="literal-block">unsigned int MagickFlopImage( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickframeimage">
<h1><a class="toc-backref" href="#id528">MagickFrameImage</a></h1>
<section id="id89">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickFrameImage( MagickWand *wand, const PixelWand *matte_color,
                               const unsigned long width, const unsigned long height,
                               const long inner_bevel, const long outer_bevel );</pre>
</section>
<section id="id90">
<h2>Description</h2>
<p>MagickFrameImage() adds a simulated three-dimensional border around the
image.  The width and height specify the border width of the vertical and
horizontal sides of the frame.  The inner and outer bevels indicate the
width of the inner and outer shadows of the frame.</p>
<p>The format of the MagickFrameImage method is:</p>
<pre class="literal-block">unsigned int MagickFrameImage( MagickWand *wand, const PixelWand *matte_color,
                               const unsigned long width, const unsigned long height,
                               const long inner_bevel, const long outer_bevel );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>matte_color:</dt>
<dd><p>The frame color pixel wand.</p>
</dd>
<dt>width:</dt>
<dd><p>The border width.</p>
</dd>
<dt>height:</dt>
<dd><p>The border height.</p>
</dd>
<dt>inner_bevel:</dt>
<dd><p>The inner bevel width.</p>
</dd>
<dt>outer_bevel:</dt>
<dd><p>The outer bevel width.</p>
</dd>
</dl>
</section>
</section>
<section id="magickfximage">
<h1><a class="toc-backref" href="#id529">MagickFxImage</a></h1>
<section id="id91">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand *MagickFxImage( MagickWand *wand, const char *expression );</pre>
</section>
<section id="id92">
<h2>Description</h2>
<p>MagickFxImage() evaluate expression for each pixel in the image.</p>
<p>The format of the MagickFxImage method is:</p>
<pre class="literal-block">MagickWand *MagickFxImage( MagickWand *wand, const char *expression );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>expression:</dt>
<dd><p>The expression.</p>
</dd>
</dl>
</section>
</section>
<section id="magickfximagechannel">
<h1><a class="toc-backref" href="#id530">MagickFxImageChannel</a></h1>
<section id="id93">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand *MagickFxImageChannel( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel,
                                  const char *expression );</pre>
</section>
<section id="id94">
<h2>Description</h2>
<p>MagickFxImageChannel() evaluate expression for each pixel in the specified
channel.</p>
<p>The format of the MagickFxImageChannel method is:</p>
<pre class="literal-block">MagickWand *MagickFxImageChannel( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel,
                                  const char *expression );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>channel:</dt>
<dd><p>Identify which channel to level: RedChannel, GreenChannel,
BlueChannel, OpacityChannel, CyanChannel, MagentaChannel, YellowChannel,
BlackChannel.</p>
</dd>
<dt>expression:</dt>
<dd><p>The expression.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgammaimage">
<h1><a class="toc-backref" href="#id531">MagickGammaImage</a></h1>
<section id="id95">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickGammaImage( MagickWand *wand, const double gamma );</pre>
</section>
<section id="id96">
<h2>Description</h2>
<p>Use MagickGammaImage() to gamma-correct an image.  The same image viewed on
different devices will have perceptual differences in the way the
image's intensities are represented on the screen.  Specify individual
gamma levels for the red, green, and blue channels, or adjust all three
with the gamma parameter.  Values typically range from 0.8 to 2.3.</p>
<p>You can also reduce the influence of a particular channel with a gamma
value of 0.</p>
<p>The format of the MagickGammaImage method is:</p>
<pre class="literal-block">unsigned int MagickGammaImage( MagickWand *wand, const double gamma );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>gamme:</dt>
<dd><p>Define the level of gamma correction.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgammaimagechannel">
<h1><a class="toc-backref" href="#id532">MagickGammaImageChannel</a></h1>
<section id="id97">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickGammaImageChannel( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel,
                                      const double gamma );</pre>
</section>
<section id="id98">
<h2>Description</h2>
<p>Use MagickGammaImageChannel() to gamma-correct a particular image channel.
The same image viewed on different devices will have perceptual differences
in the way the image's intensities are represented on the screen.  Specify
individual gamma levels for the red, green, and blue channels, or adjust all
three with the gamma parameter.  Values typically range from 0.8 to 2.3.</p>
<p>You can also reduce the influence of a particular channel with a gamma
value of 0.</p>
<p>The format of the MagickGammaImageChannel method is:</p>
<pre class="literal-block">unsigned int MagickGammaImageChannel( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel,
                                      const double gamma );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>channel:</dt>
<dd><p>The channel.</p>
</dd>
<dt>level:</dt>
<dd><p>Define the level of gamma correction.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetconfigureinfo">
<h1><a class="toc-backref" href="#id533">MagickGetConfigureInfo</a></h1>
<section id="id99">
<h2>Synopsis</h2>
<pre class="literal-block">char *MagickGetConfigureInfo( MagickWand *wand, const char *name );</pre>
</section>
<section id="id100">
<h2>Description</h2>
<p>MagickGetConfigureInfo() returns ImageMagick configure attributes such as
NAME, VERSION, LIB_VERSION, COPYRIGHT, etc.</p>
<p>The format of the MagickGetConfigureInfo() method is:</p>
<pre class="literal-block">char *MagickGetConfigureInfo( MagickWand *wand, const char *name );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>name:</dt>
<dd><p>Return the attribute associated with this name.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetcopyright">
<h1><a class="toc-backref" href="#id534">MagickGetCopyright</a></h1>
<section id="id101">
<h2>Synopsis</h2>
<pre class="literal-block">const char *MagickGetCopyright( void );</pre>
</section>
<section id="id102">
<h2>Description</h2>
<p>MagickGetCopyright() returns the ImageMagick API copyright as a string.</p>
<p>The format of the MagickGetCopyright method is:</p>
<pre class="literal-block">const char *MagickGetCopyright( void );</pre>
</section>
</section>
<section id="magickgetexception">
<h1><a class="toc-backref" href="#id535">MagickGetException</a></h1>
<section id="id103">
<h2>Synopsis</h2>
<pre class="literal-block">char *MagickGetException( const MagickWand *wand, <a class="reference external" href="../api/types.html#exceptiontype">ExceptionType</a> *severity );</pre>
</section>
<section id="id104">
<h2>Description</h2>
<p>MagickGetException() returns the severity, reason, and description of any
error that occurs when using other methods in this API.</p>
<p>The format of the MagickGetException method is:</p>
<pre class="literal-block">char *MagickGetException( const MagickWand *wand, <a class="reference external" href="../api/types.html#exceptiontype">ExceptionType</a> *severity );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>severity:</dt>
<dd><p>The severity of the error is returned here.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetfilename">
<h1><a class="toc-backref" href="#id536">MagickGetFilename</a></h1>
<section id="id105">
<h2>Synopsis</h2>
<pre class="literal-block">const char *MagickGetFilename( const MagickWand *wand );</pre>
</section>
<section id="id106">
<h2>Description</h2>
<p>MagickGetFilename() returns the filename associated with an image sequence.</p>
<p>The format of the MagickGetFilename method is:</p>
<pre class="literal-block">const char *MagickGetFilename( const MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgethomeurl">
<h1><a class="toc-backref" href="#id537">MagickGetHomeURL</a></h1>
<section id="id107">
<h2>Synopsis</h2>
<pre class="literal-block">const char *MagickGetHomeURL( void );</pre>
</section>
<section id="id108">
<h2>Description</h2>
<p>MagickGetHomeURL() returns the ImageMagick home URL.</p>
<p>The format of the MagickGetHomeURL method is:</p>
<pre class="literal-block">const char *MagickGetHomeURL( void );</pre>
</section>
</section>
<section id="magickgetimage">
<h1><a class="toc-backref" href="#id538">MagickGetImage</a></h1>
<section id="id109">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand *MagickGetImage( MagickWand *wand );</pre>
</section>
<section id="id110">
<h2>Description</h2>
<p>MagickGetImage() clones the image at the current image index.</p>
<p>The format of the MagickGetImage method is:</p>
<pre class="literal-block">MagickWand *MagickGetImage( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimageattribute">
<h1><a class="toc-backref" href="#id539">MagickGetImageAttribute</a></h1>
<section id="id111">
<h2>Synopsis</h2>
<pre class="literal-block">char *MagickGetImageAttribute( MagickWand *wand, const char *name );</pre>
</section>
<section id="id112">
<h2>Description</h2>
<p>MagickGetImageAttribute returns an image attribute as a string</p>
<p>The format of the MagickGetImageAttribute method is:</p>
<pre class="literal-block">char *MagickGetImageAttribute( MagickWand *wand, const char *name );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>name:</dt>
<dd><p>The name of the attribute</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagebackgroundcolor">
<h1><a class="toc-backref" href="#id540">MagickGetImageBackgroundColor</a></h1>
<section id="id113">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickGetImageBackgroundColor( MagickWand *wand, PixelWand *background_color );</pre>
</section>
<section id="id114">
<h2>Description</h2>
<p>MagickGetImageBackgroundColor() returns the image background color.</p>
<p>The format of the MagickGetImageBackgroundColor method is:</p>
<pre class="literal-block">unsigned int MagickGetImageBackgroundColor( MagickWand *wand, PixelWand *background_color );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>background_color:</dt>
<dd><p>Return the background color.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimageblueprimary">
<h1><a class="toc-backref" href="#id541">MagickGetImageBluePrimary</a></h1>
<section id="id115">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickGetImageBluePrimary( MagickWand *wand, double *x, double *y );</pre>
</section>
<section id="id116">
<h2>Description</h2>
<p>MagickGetImageBluePrimary() returns the chromaticy blue primary point for the
image.</p>
<p>The format of the MagickGetImageBluePrimary method is:</p>
<pre class="literal-block">unsigned int MagickGetImageBluePrimary( MagickWand *wand, double *x, double *y );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>x:</dt>
<dd><p>The chromaticity blue primary x-point.</p>
</dd>
<dt>y:</dt>
<dd><p>The chromaticity blue primary y-point.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagebordercolor">
<h1><a class="toc-backref" href="#id542">MagickGetImageBorderColor</a></h1>
<section id="id117">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickGetImageBorderColor( MagickWand *wand, PixelWand *border_color );</pre>
</section>
<section id="id118">
<h2>Description</h2>
<p>MagickGetImageBorderColor() returns the image border color.</p>
<p>The format of the MagickGetImageBorderColor method is:</p>
<pre class="literal-block">unsigned int MagickGetImageBorderColor( MagickWand *wand, PixelWand *border_color );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>border_color:</dt>
<dd><p>Return the border color.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimageboundingbox">
<h1><a class="toc-backref" href="#id543">MagickGetImageBoundingBox</a></h1>
<section id="id119">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickGetImageBoundingBox( MagickWand *wand, const double fuzz,
                                        unsigned long *width, unsigned long *height,
                                        long *x, long *y );</pre>
</section>
<section id="id120">
<h2>Description</h2>
<p>MagickGetImageBoundingBox() obtains the crop bounding box required to
remove a solid-color border from the image.  Color quantums which differ
less than the fuzz setting are considered to be the same.  If a border is
not detected, then the the original image dimensions are returned.  The
crop bounding box estimation uses the same algorithm as MagickTrimImage().</p>
<p>The format of the MagickGetImageBoundingBox method is:</p>
<pre class="literal-block">unsigned int MagickGetImageBoundingBox( MagickWand *wand, const double fuzz,
                                        unsigned long *width, unsigned long *height,
                                        long *x, long *y );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>fuzz:</dt>
<dd><p>Color comparison fuzz factor.  Use 0.0 for exact match.</p>
</dd>
<dt>width:</dt>
<dd><p>The crop width</p>
</dd>
<dt>height:</dt>
<dd><p>The crop height</p>
</dd>
<dt>x:</dt>
<dd><p>The crop x offset</p>
</dd>
<dt>y:</dt>
<dd><p>The crop y offset</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagechanneldepth">
<h1><a class="toc-backref" href="#id544">MagickGetImageChannelDepth</a></h1>
<section id="id121">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned long MagickGetImageChannelDepth( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel );</pre>
</section>
<section id="id122">
<h2>Description</h2>
<p>MagickGetImageChannelDepth() gets the depth for a particular image channel.</p>
<p>The format of the MagickGetImageChannelDepth method is:</p>
<pre class="literal-block">unsigned long MagickGetImageChannelDepth( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>channel:</dt>
<dd><p>Identify which channel to extract: RedChannel, GreenChannel,
BlueChannel, OpacityChannel, CyanChannel, MagentaChannel, YellowChannel,
BlackChannel.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagechannelextrema">
<h1><a class="toc-backref" href="#id545">MagickGetImageChannelExtrema</a></h1>
<section id="id123">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickGetImageChannelExtrema( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel,
                                           unsigned long *minima, unsigned long *maxima );</pre>
</section>
<section id="id124">
<h2>Description</h2>
<p>MagickGetImageChannelExtrema() gets the extrema for one or more image
channels.</p>
<p>The format of the MagickGetImageChannelExtrema method is:</p>
<pre class="literal-block">unsigned int MagickGetImageChannelExtrema( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel,
                                           unsigned long *minima, unsigned long *maxima );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>channel:</dt>
<dd><p>Identify which channel to extract: RedChannel, GreenChannel,
BlueChannel, OpacityChannel, CyanChannel, MagentaChannel, YellowChannel,
or BlackChannel.</p>
</dd>
<dt>minima:</dt>
<dd><p>The minimum pixel value for the specified channel(s).</p>
</dd>
<dt>maxima:</dt>
<dd><p>The maximum pixel value for the specified channel(s).</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagechannelmean">
<h1><a class="toc-backref" href="#id546">MagickGetImageChannelMean</a></h1>
<section id="id125">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickGetImageChannelMean( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel,
                                        double *mean, double *standard_deviation );</pre>
</section>
<section id="id126">
<h2>Description</h2>
<p>MagickGetImageChannelMean() gets the mean and standard deviation of one or
more image channels.</p>
<p>The format of the MagickGetImageChannelMean method is:</p>
<pre class="literal-block">unsigned int MagickGetImageChannelMean( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel,
                                        double *mean, double *standard_deviation );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>channel:</dt>
<dd><p>Identify which channel to extract: RedChannel, GreenChannel,
BlueChannel, OpacityChannel, CyanChannel, MagentaChannel, YellowChannel,
or BlackChannel.</p>
</dd>
<dt>mean:</dt>
<dd><p>The mean pixel value for the specified channel(s).</p>
</dd>
<dt>standard_deviation:</dt>
<dd><p>The standard deviation for the specified channel(s).</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagecolormapcolor">
<h1><a class="toc-backref" href="#id547">MagickGetImageColormapColor</a></h1>
<section id="id127">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickGetImageColormapColor( MagickWand *wand, const unsigned long index,
                                          PixelWand *color );</pre>
</section>
<section id="id128">
<h2>Description</h2>
<p>MagickGetImageColormapColor() returns the color of the specified colormap
index.</p>
<p>The format of the MagickGetImageColormapColor method is:</p>
<pre class="literal-block">unsigned int MagickGetImageColormapColor( MagickWand *wand, const unsigned long index,
                                          PixelWand *color );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>index:</dt>
<dd><p>The offset into the image colormap.</p>
</dd>
<dt>color:</dt>
<dd><p>Return the colormap color in this wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagecolors">
<h1><a class="toc-backref" href="#id548">MagickGetImageColors</a></h1>
<section id="id129">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned long MagickGetImageColors( MagickWand *wand );</pre>
</section>
<section id="id130">
<h2>Description</h2>
<p>MagickGetImageColors() gets the number of unique colors in the image.</p>
<p>The format of the MagickGetImageColors method is:</p>
<pre class="literal-block">unsigned long MagickGetImageColors( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagecolorspace">
<h1><a class="toc-backref" href="#id549">MagickGetImageColorspace</a></h1>
<section id="id131">
<h2>Synopsis</h2>
<pre class="literal-block"><a class="reference external" href="../api/types.html#colorspacetype">ColorspaceType</a> MagickGetImageColorspace( MagickWand *wand );</pre>
</section>
<section id="id132">
<h2>Description</h2>
<p>MagickGetImageColorspace() gets the image colorspace.</p>
<p>The format of the MagickGetImageColorspace method is:</p>
<pre class="literal-block"><a class="reference external" href="../api/types.html#colorspacetype">ColorspaceType</a> MagickGetImageColorspace( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagecompose">
<h1><a class="toc-backref" href="#id550">MagickGetImageCompose</a></h1>
<section id="id133">
<h2>Synopsis</h2>
<pre class="literal-block"><a class="reference external" href="../api/types.html#compositeoperator">CompositeOperator</a> MagickGetImageCompose( MagickWand *wand );</pre>
</section>
<section id="id134">
<h2>Description</h2>
<p>MagickGetImageCompose() returns the composite operator associated with the
image.</p>
<p>The format of the MagickGetImageCompose method is:</p>
<pre class="literal-block"><a class="reference external" href="../api/types.html#compositeoperator">CompositeOperator</a> MagickGetImageCompose( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagecompression">
<h1><a class="toc-backref" href="#id551">MagickGetImageCompression</a></h1>
<section id="id135">
<h2>Synopsis</h2>
<pre class="literal-block"><a class="reference external" href="../api/types.html#compressiontype">CompressionType</a> MagickGetImageCompression( MagickWand *wand );</pre>
</section>
<section id="id136">
<h2>Description</h2>
<p>MagickGetImageCompression() gets the image compression.</p>
<p>The format of the MagickGetImageCompression method is:</p>
<pre class="literal-block"><a class="reference external" href="../api/types.html#compressiontype">CompressionType</a> MagickGetImageCompression( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagedelay">
<h1><a class="toc-backref" href="#id552">MagickGetImageDelay</a></h1>
<section id="id137">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned long MagickGetImageDelay( MagickWand *wand );</pre>
</section>
<section id="id138">
<h2>Description</h2>
<p>MagickGetImageDelay() gets the image delay.</p>
<p>The format of the MagickGetImageDelay method is:</p>
<pre class="literal-block">unsigned long MagickGetImageDelay( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagedepth">
<h1><a class="toc-backref" href="#id553">MagickGetImageDepth</a></h1>
<section id="id139">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned long MagickGetImageDepth( MagickWand *wand );</pre>
</section>
<section id="id140">
<h2>Description</h2>
<p>MagickGetImageDepth() gets the image depth.</p>
<p>The format of the MagickGetImageDepth method is:</p>
<pre class="literal-block">unsigned long MagickGetImageDepth( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimageextrema">
<h1><a class="toc-backref" href="#id554">MagickGetImageExtrema</a></h1>
<section id="id141">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickGetImageExtrema( MagickWand *wand, unsigned long *min,
                                    unsigned long *max );</pre>
</section>
<section id="id142">
<h2>Description</h2>
<p>MagickGetImageExtrema() gets the extrema for the image.</p>
<p>The format of the MagickGetImageExtrema method is:</p>
<pre class="literal-block">unsigned int MagickGetImageExtrema( MagickWand *wand, unsigned long *min,
                                    unsigned long *max );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>min:</dt>
<dd><p>The minimum pixel value for the specified channel(s).</p>
</dd>
<dt>max:</dt>
<dd><p>The maximum pixel value for the specified channel(s).</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagedispose">
<h1><a class="toc-backref" href="#id555">MagickGetImageDispose</a></h1>
<section id="id143">
<h2>Synopsis</h2>
<pre class="literal-block">DisposeType MagickGetImageDispose( MagickWand *wand );</pre>
</section>
<section id="id144">
<h2>Description</h2>
<p>MagickGetImageDispose() gets the image disposal method.</p>
<p>The format of the MagickGetImageDispose method is:</p>
<pre class="literal-block">DisposeType MagickGetImageDispose( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagefilename">
<h1><a class="toc-backref" href="#id556">MagickGetImageFilename</a></h1>
<section id="id145">
<h2>Synopsis</h2>
<pre class="literal-block">const char MagickGetImageFilename( MagickWand *wand );</pre>
</section>
<section id="id146">
<h2>Description</h2>
<p>MagickGetImageFilename() returns the filename of a particular image in a
sequence.</p>
<p>The format of the MagickGetImageFilename method is:</p>
<pre class="literal-block">const char MagickGetImageFilename( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimageformat">
<h1><a class="toc-backref" href="#id557">MagickGetImageFormat</a></h1>
<section id="id147">
<h2>Synopsis</h2>
<pre class="literal-block">const char MagickGetImageFormat( MagickWand *wand );</pre>
</section>
<section id="id148">
<h2>Description</h2>
<p>MagickGetImageFormat() returns the format of a particular image in a
sequence.</p>
<p>The format of the MagickGetImageFormat method is:</p>
<pre class="literal-block">const char MagickGetImageFormat( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagefuzz">
<h1><a class="toc-backref" href="#id558">MagickGetImageFuzz</a></h1>
<section id="id149">
<h2>Synopsis</h2>
<pre class="literal-block">double MagickGetImageFuzz( MagickWand *wand );</pre>
</section>
<section id="id150">
<h2>Description</h2>
<p>MagickGetImageFuzz() returns the color comparison fuzz factor. Colors
closer than the fuzz factor are considered to be the same when comparing
colors.  Note that some other functions such as MagickColorFloodfillImage()
implicitly set this value.</p>
<p>The format of the MagickGetImageFuzz method is:</p>
<pre class="literal-block">double MagickGetImageFuzz( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagegamma">
<h1><a class="toc-backref" href="#id559">MagickGetImageGamma</a></h1>
<section id="id151">
<h2>Synopsis</h2>
<pre class="literal-block">double MagickGetImageGamma( MagickWand *wand );</pre>
</section>
<section id="id152">
<h2>Description</h2>
<p>MagickGetImageGamma() gets the image gamma.</p>
<p>The format of the MagickGetImageGamma method is:</p>
<pre class="literal-block">double MagickGetImageGamma( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagegeometry">
<h1><a class="toc-backref" href="#id560">MagickGetImageGeometry</a></h1>
<section id="id153">
<h2>Synopsis</h2>
<pre class="literal-block">const char *MagickGetImageGeometry( MagickWand *wand );</pre>
</section>
<section id="id154">
<h2>Description</h2>
<p>MagickGetImageGeometry() gets the image geometry string.  NULL is
returned if the image does not contain a geometry string.</p>
<p>The format of the MagickGetImageGeometry method is:</p>
<pre class="literal-block">const char *MagickGetImageGeometry( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagegravity">
<h1><a class="toc-backref" href="#id561">MagickGetImageGravity</a></h1>
<section id="id155">
<h2>Synopsis</h2>
<pre class="literal-block"><a class="reference external" href="../api/types.html#gravitytype">GravityType</a> MagickGetImageGravity( MagickWand *wand );</pre>
</section>
<section id="id156">
<h2>Description</h2>
<p>MagickGetImageGravity() gets the image gravity.</p>
<p>The format of the MagickGetImageGravity method is:</p>
<pre class="literal-block"><a class="reference external" href="../api/types.html#gravitytype">GravityType</a> MagickGetImageGravity( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagegreenprimary">
<h1><a class="toc-backref" href="#id562">MagickGetImageGreenPrimary</a></h1>
<section id="id157">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickGetImageGreenPrimary( MagickWand *wand, double *x, double *y );</pre>
</section>
<section id="id158">
<h2>Description</h2>
<p>MagickGetImageGreenPrimary() returns the chromaticy green primary point.</p>
<p>The format of the MagickGetImageGreenPrimary method is:</p>
<pre class="literal-block">unsigned int MagickGetImageGreenPrimary( MagickWand *wand, double *x, double *y );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>x:</dt>
<dd><p>The chromaticity green primary x-point.</p>
</dd>
<dt>y:</dt>
<dd><p>The chromaticity green primary y-point.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimageheight">
<h1><a class="toc-backref" href="#id563">MagickGetImageHeight</a></h1>
<section id="id159">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned long MagickGetImageHeight( MagickWand *wand );</pre>
</section>
<section id="id160">
<h2>Description</h2>
<p>MagickGetImageHeight() returns the image height.</p>
<p>The format of the MagickGetImageHeight method is:</p>
<pre class="literal-block">unsigned long MagickGetImageHeight( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagehistogram">
<h1><a class="toc-backref" href="#id564">MagickGetImageHistogram</a></h1>
<section id="id161">
<h2>Synopsis</h2>
<pre class="literal-block">PixelWand *MagickGetImageHistogram( MagickWand *wand, unsigned long *number_colors );</pre>
</section>
<section id="id162">
<h2>Description</h2>
<p>MagickGetImageHistogram() returns the image histogram as an array of
PixelWand wands.</p>
<p>The format of the MagickGetImageHistogram method is:</p>
<pre class="literal-block">PixelWand *MagickGetImageHistogram( MagickWand *wand, unsigned long *number_colors );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>number_colors:</dt>
<dd><p>The number of unique colors in the image and the number
of pixel wands returned.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimageindex">
<h1><a class="toc-backref" href="#id565">MagickGetImageIndex</a></h1>
<section id="id163">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickGetImageIndex( MagickWand *wand );</pre>
</section>
<section id="id164">
<h2>Description</h2>
<p>MagickGetImageIndex() returns the index of the current image.</p>
<p>The format of the MagickGetImageIndex method is:</p>
<pre class="literal-block">unsigned int MagickGetImageIndex( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimageinterlacescheme">
<h1><a class="toc-backref" href="#id566">MagickGetImageInterlaceScheme</a></h1>
<section id="id165">
<h2>Synopsis</h2>
<pre class="literal-block"><a class="reference external" href="../api/types.html#interlacetype">InterlaceType</a> MagickGetImageInterlaceScheme( MagickWand *wand );</pre>
</section>
<section id="id166">
<h2>Description</h2>
<p>MagickGetImageInterlaceScheme() gets the image interlace scheme.</p>
<p>The format of the MagickGetImageInterlaceScheme method is:</p>
<pre class="literal-block"><a class="reference external" href="../api/types.html#interlacetype">InterlaceType</a> MagickGetImageInterlaceScheme( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimageiterations">
<h1><a class="toc-backref" href="#id567">MagickGetImageIterations</a></h1>
<section id="id167">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned long MagickGetImageIterations( MagickWand *wand );</pre>
</section>
<section id="id168">
<h2>Description</h2>
<p>MagickGetImageIterations() gets the image iterations.</p>
<p>The format of the MagickGetImageIterations method is:</p>
<pre class="literal-block">unsigned long MagickGetImageIterations( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagematte">
<h1><a class="toc-backref" href="#id568">MagickGetImageMatte</a></h1>
<section id="id169">
<h2>Synopsis</h2>
<pre class="literal-block">MagickBool MagickGetImageMatte( MagickWand *wand );</pre>
</section>
<section id="id170">
<h2>Description</h2>
<p>MagickGetImageMatte() gets the image matte flag.  The flag is MagickTrue
if the image supports an opacity (inverse of transparency) channel.</p>
<p>The format of the MagickGetImageMatte method is:</p>
<pre class="literal-block">MagickBool MagickGetImageMatte( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagemattecolor">
<h1><a class="toc-backref" href="#id569">MagickGetImageMatteColor</a></h1>
<section id="id171">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickGetImageMatteColor( MagickWand *wand, PixelWand *matte_color );</pre>
</section>
<section id="id172">
<h2>Description</h2>
<p>MagickGetImageMatteColor() returns the image matte color.</p>
<p>The format of the MagickGetImageMatteColor method is:</p>
<pre class="literal-block">unsigned int MagickGetImageMatteColor( MagickWand *wand, PixelWand *matte_color );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>matte_color:</dt>
<dd><p>Return the matte color.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimageorientation">
<h1><a class="toc-backref" href="#id570">MagickGetImageOrientation</a></h1>
<section id="id173">
<h2>Synopsis</h2>
<pre class="literal-block">OrientationType MagickGetImageOrientation( MagickWand *wand );</pre>
</section>
<section id="id174">
<h2>Description</h2>
<p>MagickGetImageOrientation() gets the image orientation type. May be one of:</p>
<p>UndefinedOrientation    Image orientation not specified or error.
TopLeftOrientation      Left to right and Top to bottom.
TopRightOrientation     Right to left  and Top to bottom.
BottomRightOrientation  Right to left and Bottom to top.
BottomLeftOrientation   Left to right and Bottom to top.
LeftTopOrientation      Top to bottom and Left to right.
RightTopOrientation     Top to bottom and Right to left.
RightBottomOrientation  Bottom to top and Right to left.
LeftBottomOrientation   Bottom to top and Left to right.</p>
<p>The format of the MagickGetImageOrientation method is:</p>
<pre class="literal-block">OrientationType MagickGetImageOrientation( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagepage">
<h1><a class="toc-backref" href="#id571">MagickGetImagePage</a></h1>
<section id="id175">
<h2>Synopsis</h2>
<pre class="literal-block">MagickGetImagePage( MagickWand *wand, unsigned long *width, unsigned long *height, long *x,
                    long *y );</pre>
</section>
<section id="id176">
<h2>Description</h2>
<p>MagickGetImagePage() retrieves the image page size and offset used when
placing (e.g. compositing) the image.</p>
<p>The format of the MagickGetImagePage method is:</p>
<pre class="literal-block">MagickGetImagePage( MagickWand *wand, unsigned long *width, unsigned long *height, long *x,
                    long *y );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>width, height:</dt>
<dd><p>The region size.</p>
</dd>
<dt>x, y:</dt>
<dd><p>Offset (from top left) on base canvas image on
which to composite image data.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagepixels">
<h1><a class="toc-backref" href="#id572">MagickGetImagePixels</a></h1>
<section id="id177">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickGetImagePixels( MagickWand *wand, const long x_offset, const long y_offset,
                                   const unsigned long columns, const unsigned long rows,
                                   const char *map, const <a class="reference external" href="../api/types.html#storagetype">StorageType</a> storage,
                                   unsigned char *pixels );</pre>
</section>
<section id="id178">
<h2>Description</h2>
<p>MagickGetImagePixels() extracts pixel data from an image and returns it to
you.  The method returns False on success otherwise True if an error is
encountered.  The data is returned as char, short int, int, long, float,
or double in the order specified by map.</p>
<p>Suppose you want to extract the first scanline of a 640x480 image as
character data in red-green-blue order:</p>
<p>MagickGetImagePixels(wand,0,0,640,1,&quot;RGB&quot;,CharPixel,pixels);</p>
<p>The format of the MagickGetImagePixels method is:</p>
<pre class="literal-block">unsigned int MagickGetImagePixels( MagickWand *wand, const long x_offset, const long y_offset,
                                   const unsigned long columns, const unsigned long rows,
                                   const char *map, const <a class="reference external" href="../api/types.html#storagetype">StorageType</a> storage,
                                   unsigned char *pixels );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>x_offset, y_offset, columns, rows:</dt>
<dd><p>These values define the perimeter
of a region of pixels you want to extract.</p>
</dd>
<dt>map:</dt>
<dd><p>This string reflects the expected ordering of the pixel array.
It can be any combination or order of R = red, G = green, B = blue,
A = alpha, C = cyan, Y = yellow, M = magenta, K = black, or
I = intensity (for grayscale).</p>
</dd>
<dt>storage:</dt>
<dd><p>Define the data type of the pixels.  Float and double types are
expected to be normalized [0..1] otherwise [0..MaxRGB].  Choose from
these types: CharPixel, ShortPixel, IntegerPixel, LongPixel, FloatPixel,
or DoublePixel.</p>
</dd>
<dt>pixels:</dt>
<dd><p>This array of values contain the pixel components as defined by
map and type.  You must preallocate this array where the expected
length varies depending on the values of width, height, map, and type.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimageprofile">
<h1><a class="toc-backref" href="#id573">MagickGetImageProfile</a></h1>
<section id="id179">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned char *MagickGetImageProfile( MagickWand *wand, const char *name,
                                      unsigned long *length );</pre>
</section>
<section id="id180">
<h2>Description</h2>
<p>MagickGetImageProfile() returns the named image profile.</p>
<p>The format of the MagickGetImageProfile method is:</p>
<pre class="literal-block">unsigned char *MagickGetImageProfile( MagickWand *wand, const char *name,
                                      unsigned long *length );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>name:</dt>
<dd><p>Name of profile to return: ICC, IPTC, or generic profile.</p>
</dd>
<dt>length:</dt>
<dd><p>The length of the profile.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimageredprimary">
<h1><a class="toc-backref" href="#id574">MagickGetImageRedPrimary</a></h1>
<section id="id181">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickGetImageRedPrimary( MagickWand *wand, double *x, double *y );</pre>
</section>
<section id="id182">
<h2>Description</h2>
<p>MagickGetImageRedPrimary() returns the chromaticy red primary point.</p>
<p>The format of the MagickGetImageRedPrimary method is:</p>
<pre class="literal-block">unsigned int MagickGetImageRedPrimary( MagickWand *wand, double *x, double *y );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>x:</dt>
<dd><p>The chromaticity red primary x-point.</p>
</dd>
<dt>y:</dt>
<dd><p>The chromaticity red primary y-point.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagerenderingintent">
<h1><a class="toc-backref" href="#id575">MagickGetImageRenderingIntent</a></h1>
<section id="id183">
<h2>Synopsis</h2>
<pre class="literal-block"><a class="reference external" href="../api/types.html#renderingintent">RenderingIntent</a> MagickGetImageRenderingIntent( MagickWand *wand );</pre>
</section>
<section id="id184">
<h2>Description</h2>
<p>MagickGetImageRenderingIntent() gets the image rendering intent.</p>
<p>The format of the MagickGetImageRenderingIntent method is:</p>
<pre class="literal-block"><a class="reference external" href="../api/types.html#renderingintent">RenderingIntent</a> MagickGetImageRenderingIntent( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimageresolution">
<h1><a class="toc-backref" href="#id576">MagickGetImageResolution</a></h1>
<section id="id185">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickGetImageResolution( MagickWand *wand, double *x, double *y );</pre>
</section>
<section id="id186">
<h2>Description</h2>
<p>MagickGetImageResolution() gets the image X &amp; Y resolution.</p>
<p>The format of the  MagickGetImageResolution method is:</p>
<pre class="literal-block">unsigned int MagickGetImageResolution( MagickWand *wand, double *x, double *y );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>x:</dt>
<dd><p>The image x-resolution.</p>
</dd>
<dt>y:</dt>
<dd><p>The image y-resolution.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagescene">
<h1><a class="toc-backref" href="#id577">MagickGetImageScene</a></h1>
<section id="id187">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned long MagickGetImageScene( MagickWand *wand );</pre>
</section>
<section id="id188">
<h2>Description</h2>
<p>MagickGetImageScene() gets the image scene.</p>
<p>The format of the MagickGetImageScene method is:</p>
<pre class="literal-block">unsigned long MagickGetImageScene( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagesignature">
<h1><a class="toc-backref" href="#id578">MagickGetImageSignature</a></h1>
<section id="id189">
<h2>Synopsis</h2>
<pre class="literal-block">const char MagickGetImageSignature( MagickWand *wand );</pre>
</section>
<section id="id190">
<h2>Description</h2>
<p>MagickGetImageSignature() generates an SHA-256 message digest for the image
pixel stream.</p>
<p>The format of the MagickGetImageSignature method is:</p>
<pre class="literal-block">const char MagickGetImageSignature( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagesize">
<h1><a class="toc-backref" href="#id579">MagickGetImageSize</a></h1>
<section id="id191">
<h2>Synopsis</h2>
<pre class="literal-block">MagickSizeType MagickGetImageSize( MagickWand *wand );</pre>
</section>
<section id="id192">
<h2>Description</h2>
<p>MagickGetImageSize() returns the image size.</p>
<p>The format of the MagickGetImageSize method is:</p>
<pre class="literal-block">MagickSizeType MagickGetImageSize( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagetype">
<h1><a class="toc-backref" href="#id580">MagickGetImageType</a></h1>
<section id="id193">
<h2>Synopsis</h2>
<pre class="literal-block"><a class="reference external" href="../api/types.html#imagetype">ImageType</a> MagickGetImageType( MagickWand *wand );</pre>
</section>
<section id="id194">
<h2>Description</h2>
<p>MagickGetImageType() gets the image type.</p>
<p>The format of the MagickGetImageType method is:</p>
<pre class="literal-block"><a class="reference external" href="../api/types.html#imagetype">ImageType</a> MagickGetImageType( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagesavedtype">
<h1><a class="toc-backref" href="#id581">MagickGetImageSavedType</a></h1>
<section id="id195">
<h2>Synopsis</h2>
<pre class="literal-block"><a class="reference external" href="../api/types.html#imagetype">ImageType</a> MagickGetImageSavedType( MagickWand *wand );</pre>
</section>
<section id="id196">
<h2>Description</h2>
<p>MagickGetImageSavedType() gets the image type that will be used when the
image is saved. This may be different to the current image type, returned
by MagickGetImageType().</p>
<p>The format of the MagickGetImageSavedType method is:</p>
<pre class="literal-block"><a class="reference external" href="../api/types.html#imagetype">ImageType</a> MagickGetImageSavedType( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimageunits">
<h1><a class="toc-backref" href="#id582">MagickGetImageUnits</a></h1>
<section id="id197">
<h2>Synopsis</h2>
<pre class="literal-block"><a class="reference external" href="../api/types.html#resolutiontype">ResolutionType</a> MagickGetImageUnits( MagickWand *wand );</pre>
</section>
<section id="id198">
<h2>Description</h2>
<p>MagickGetImageUnits() gets the image units of resolution.</p>
<p>The format of the MagickGetImageUnits method is:</p>
<pre class="literal-block"><a class="reference external" href="../api/types.html#resolutiontype">ResolutionType</a> MagickGetImageUnits( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagevirtualpixelmethod">
<h1><a class="toc-backref" href="#id583">MagickGetImageVirtualPixelMethod</a></h1>
<section id="id199">
<h2>Synopsis</h2>
<pre class="literal-block"><a class="reference external" href="../api/types.html#virtualpixelmethod">VirtualPixelMethod</a> MagickGetImageVirtualPixelMethod( MagickWand *wand );</pre>
</section>
<section id="id200">
<h2>Description</h2>
<p>MagickGetImageVirtualPixelMethod() returns the virtual pixel method for the
sepcified image.</p>
<p>The format of the MagickGetImageVirtualPixelMethod method is:</p>
<pre class="literal-block"><a class="reference external" href="../api/types.html#virtualpixelmethod">VirtualPixelMethod</a> MagickGetImageVirtualPixelMethod( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagewhitepoint">
<h1><a class="toc-backref" href="#id584">MagickGetImageWhitePoint</a></h1>
<section id="id201">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickGetImageWhitePoint( MagickWand *wand, double *x, double *y );</pre>
</section>
<section id="id202">
<h2>Description</h2>
<p>MagickGetImageWhitePoint() returns the chromaticy white point.</p>
<p>The format of the MagickGetImageWhitePoint method is:</p>
<pre class="literal-block">unsigned int MagickGetImageWhitePoint( MagickWand *wand, double *x, double *y );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>x:</dt>
<dd><p>The chromaticity white x-point.</p>
</dd>
<dt>y:</dt>
<dd><p>The chromaticity white y-point.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetimagewidth">
<h1><a class="toc-backref" href="#id585">MagickGetImageWidth</a></h1>
<section id="id203">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned long MagickGetImageWidth( MagickWand *wand );</pre>
</section>
<section id="id204">
<h2>Description</h2>
<p>MagickGetImageWidth() returns the image width.</p>
<p>The format of the MagickGetImageWidth method is:</p>
<pre class="literal-block">unsigned long MagickGetImageWidth( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetnumberimages">
<h1><a class="toc-backref" href="#id586">MagickGetNumberImages</a></h1>
<section id="id205">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned long MagickGetNumberImages( MagickWand *wand );</pre>
</section>
<section id="id206">
<h2>Description</h2>
<p>MagickGetNumberOfImages() returns the number of images associated with a
magick wand.</p>
<p>The format of the MagickGetNumberImages method is:</p>
<pre class="literal-block">unsigned long MagickGetNumberImages( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetpackagename">
<h1><a class="toc-backref" href="#id587">MagickGetPackageName</a></h1>
<section id="id207">
<h2>Synopsis</h2>
<pre class="literal-block">const char *MagickGetPackageName( void );</pre>
</section>
<section id="id208">
<h2>Description</h2>
<p>MagickGetPackageName() returns the ImageMagick package name.</p>
<p>The format of the MagickGetPackageName method is:</p>
<pre class="literal-block">const char *MagickGetPackageName( void );</pre>
</section>
</section>
<section id="magickgetquantumdepth">
<h1><a class="toc-backref" href="#id588">MagickGetQuantumDepth</a></h1>
<section id="id209">
<h2>Synopsis</h2>
<pre class="literal-block">const char *MagickGetQuantumDepth( unsigned long *depth );</pre>
</section>
<section id="id210">
<h2>Description</h2>
<p>MagickGetQuantumDepth() returns the ImageMagick quantum depth.</p>
<p>The format of the MagickGetQuantumDepth method is:</p>
<pre class="literal-block">const char *MagickGetQuantumDepth( unsigned long *depth );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>depth:</dt>
<dd><p>The quantum depth is returned as a number.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetreleasedate">
<h1><a class="toc-backref" href="#id589">MagickGetReleaseDate</a></h1>
<section id="id211">
<h2>Synopsis</h2>
<pre class="literal-block">const char *MagickGetReleaseDate( void );</pre>
</section>
<section id="id212">
<h2>Description</h2>
<p>MagickGetReleaseDate() returns the ImageMagick release date.</p>
<p>The format of the MagickGetReleaseDate method is:</p>
<pre class="literal-block">const char *MagickGetReleaseDate( void );</pre>
</section>
</section>
<section id="magickgetresourcelimit">
<h1><a class="toc-backref" href="#id590">MagickGetResourceLimit</a></h1>
<section id="id213">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned long MagickGetResourceLimit( const <a class="reference external" href="../api/types.html#resourcetype">ResourceType</a> type );</pre>
</section>
<section id="id214">
<h2>Description</h2>
<p>MagickGetResourceLimit() returns the the specified resource in megabytes.</p>
<p>The format of the MagickGetResourceLimit method is:</p>
<pre class="literal-block">unsigned long MagickGetResourceLimit( const <a class="reference external" href="../api/types.html#resourcetype">ResourceType</a> type );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetsamplingfactors">
<h1><a class="toc-backref" href="#id591">MagickGetSamplingFactors</a></h1>
<section id="id215">
<h2>Synopsis</h2>
<pre class="literal-block">double *MagickGetSamplingFactors( MagickWand *wand, unsigned long *number_factors );</pre>
</section>
<section id="id216">
<h2>Description</h2>
<p>MagickGetSamplingFactors() gets the horizontal and vertical sampling factor.</p>
<p>The format of the MagickGetSamplingFactors method is:</p>
<pre class="literal-block">double *MagickGetSamplingFactors( MagickWand *wand, unsigned long *number_factors );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>number_factors:</dt>
<dd><p>The number of factors in the returned array.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetsize">
<h1><a class="toc-backref" href="#id592">MagickGetSize</a></h1>
<section id="id217">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickGetSize( const MagickWand *wand, unsigned long *columns,
                            unsigned long *rows );</pre>
</section>
<section id="id218">
<h2>Description</h2>
<p>MagickGetSize() returns the size associated with the magick wand.</p>
<p>The format of the MagickGetSize method is:</p>
<pre class="literal-block">unsigned int MagickGetSize( const MagickWand *wand, unsigned long *columns,
                            unsigned long *rows );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>columns:</dt>
<dd><p>The width in pixels.</p>
</dd>
<dt>height:</dt>
<dd><p>The height in pixels.</p>
</dd>
</dl>
</section>
</section>
<section id="magickgetversion">
<h1><a class="toc-backref" href="#id593">MagickGetVersion</a></h1>
<section id="id219">
<h2>Synopsis</h2>
<pre class="literal-block">const char *MagickGetVersion( unsigned long *version );</pre>
</section>
<section id="id220">
<h2>Description</h2>
<p>MagickGetVersion() returns the ImageMagick API version as a string and
as a number.</p>
<p>The format of the MagickGetVersion method is:</p>
<pre class="literal-block">const char *MagickGetVersion( unsigned long *version );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>version:</dt>
<dd><p>The ImageMagick version is returned as a number.</p>
</dd>
</dl>
</section>
</section>
<section id="magickhaldclutimage">
<h1><a class="toc-backref" href="#id594">MagickHaldClutImage</a></h1>
<section id="id221">
<h2>Synopsis</h2>
<pre class="literal-block">MagickPassFail MagickHaldClutImage( MagickWand *wand, const MagickWand *clut_wand );</pre>
</section>
<section id="id222">
<h2>Description</h2>
<p>The MagickHaldClutImage() method apply a color lookup table (Hald CLUT) to
the image.  The fundamental principle of the Hald CLUT algorithm is that
application of an identity CLUT causes no change to the input image,
but an identity CLUT image which has had its colors transformed in
some way (e.g. in Adobe Photoshop) may be used to implement an identical
transform on any other image.</p>
<p>The minimum CLUT level is 2, and the maximum depends on available memory
(largest successfully tested is 24).  A CLUT image is required to have equal
width and height. A CLUT of level 8 is an image of dimension 512x512, a CLUT
of level 16 is an image of dimension 4096x4096.  Interpolation is used so
extremely large CLUT images are not required.</p>
<p>GraphicsMagick provides an 'identity' coder which may be used to generate
identity HLUTs.  For example, reading from &quot;identity:8&quot; creates an identity
CLUT of order 8.</p>
<p>The Hald CLUT algorithm has been developed by Eskil Steenberg as described
at <a class="reference external" href="http://www.quelsolaar.com/technology/clut.html">http://www.quelsolaar.com/technology/clut.html</a>, and was adapted for
GraphicsMagick by Clément Follet with support from Cédric Lejeune of
Workflowers.</p>
<p>The format of the HaldClutImage method is:</p>
<pre class="literal-block">MagickPassFail MagickHaldClutImage( MagickWand *wand, const MagickWand *clut_wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The image wand.</p>
</dd>
<dt>clut_wand:</dt>
<dd><p>The color lookup table image wand</p>
</dd>
</dl>
</section>
</section>
<section id="magickhascolormap">
<h1><a class="toc-backref" href="#id595">MagickHasColormap</a></h1>
<section id="id223">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickHasColormap( MagickWand *wand, unsigned int *colormap );</pre>
</section>
<section id="id224">
<h2>Description</h2>
<p>MagickHasColormap() returns True if the check was successful with the
colormap parameter set to a boolean value indicating whether the current
wand image uses a color map or not. Returns False if there are no wand
images available.</p>
<p>The format of the MagickHasColormap method is:</p>
<pre class="literal-block">unsigned int MagickHasColormap( MagickWand *wand, unsigned int *colormap );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>colormap:</dt>
<dd><p>Set to True if current image uses a color map, False if not.</p>
</dd>
</dl>
</section>
</section>
<section id="magickhasnextimage">
<h1><a class="toc-backref" href="#id596">MagickHasNextImage</a></h1>
<section id="id225">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickHasNextImage( MagickWand *wand );</pre>
</section>
<section id="id226">
<h2>Description</h2>
<p>MagickHasNextImage() returns True if the wand has more images when
traversing the list in the forward direction</p>
<p>The format of the MagickHasNextImage method is:</p>
<pre class="literal-block">unsigned int MagickHasNextImage( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickhaspreviousimage">
<h1><a class="toc-backref" href="#id597">MagickHasPreviousImage</a></h1>
<section id="id227">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickHasPreviousImage( MagickWand *wand );</pre>
</section>
<section id="id228">
<h2>Description</h2>
<p>MagickHasPreviousImage() returns True if the wand has more images when
traversing the list in the reverse direction</p>
<p>The format of the MagickHasPreviousImage method is:</p>
<pre class="literal-block">unsigned int MagickHasPreviousImage( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickimplodeimage">
<h1><a class="toc-backref" href="#id598">MagickImplodeImage</a></h1>
<section id="id229">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickImplodeImage( MagickWand *wand, const double radius );</pre>
</section>
<section id="id230">
<h2>Description</h2>
<p>MagickImplodeImage() creates a new image that is a copy of an existing
one with the image pixels &quot;implode&quot; by the specified percentage.  It
allocates the memory necessary for the new Image structure and returns a
pointer to the new image.</p>
<p>The format of the MagickImplodeImage method is:</p>
<pre class="literal-block">unsigned int MagickImplodeImage( MagickWand *wand, const double radius );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>amount:</dt>
<dd><p>Define the extent of the implosion.</p>
</dd>
</dl>
</section>
</section>
<section id="magickisgrayimage">
<h1><a class="toc-backref" href="#id599">MagickIsGrayImage</a></h1>
<section id="id231">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickIsGrayImage( MagickWand *wand, unsigned int *grayimage );</pre>
</section>
<section id="id232">
<h2>Description</h2>
<p>MagickIsGrayImage() returns True if the check was successful with the
grayimage parameter set to a boolean value indicating whether the current
wand image is a gray-scale image or not. Returns False if there was
an error.</p>
<p>The format of the MagickIsGrayImage method is:</p>
<pre class="literal-block">unsigned int MagickIsGrayImage( MagickWand *wand, unsigned int *grayimage );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>grayimage:</dt>
<dd><p>Set to True if current image is a gray-scale image,
False if not.</p>
</dd>
</dl>
</section>
</section>
<section id="magickismonochromeimage">
<h1><a class="toc-backref" href="#id600">MagickIsMonochromeImage</a></h1>
<section id="id233">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickIsMonochromeImage( MagickWand *wand, unsigned int *monochrome );</pre>
</section>
<section id="id234">
<h2>Description</h2>
<p>MagickIsMonochromeImage() returns True if the check was successful with the
monochrome parameter set to a boolean value indicating whether the current
wand image is a monochrome image or not. Returns False if there was
an error.</p>
<p>The format of the MagickIsMonochromeImage method is:</p>
<pre class="literal-block">unsigned int MagickIsMonochromeImage( MagickWand *wand, unsigned int *monochrome );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>monochrome:</dt>
<dd><p>Set to True if current image is a monochrome image,
False if not.</p>
</dd>
</dl>
</section>
</section>
<section id="magickisopaqueimage">
<h1><a class="toc-backref" href="#id601">MagickIsOpaqueImage</a></h1>
<section id="id235">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickIsOpaqueImage( MagickWand *wand, unsigned int *opaque );</pre>
</section>
<section id="id236">
<h2>Description</h2>
<p>MagickIsOpaqueImage() returns True if the check was successful with the
opaque parameter set to a boolean value indicating whether the current
wand image is entirely opaque or not. Returns False if there was
an error.</p>
<p>The format of the MagickIsOpaqueImage method is:</p>
<pre class="literal-block">unsigned int MagickIsOpaqueImage( MagickWand *wand, unsigned int *opaque );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>opaque:</dt>
<dd><p>Set to True if current image is entirely opaque,
False if not.</p>
</dd>
</dl>
</section>
</section>
<section id="magickispaletteimage">
<h1><a class="toc-backref" href="#id602">MagickIsPaletteImage</a></h1>
<section id="id237">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickIsPaletteImage( MagickWand *wand, unsigned int *palette );</pre>
</section>
<section id="id238">
<h2>Description</h2>
<p>MagickIsPaletteImage() returns True if the check was successful with the
palette parameter set to a boolean value indicating whether the current
wand image is an image with 256 unique colors or less. Returns False if
there was an error. Note that a palette image does not necessarily use a
colormap. See MagickHasColormap() if needing to determine whether a
colormap is in use.</p>
<p>The format of the MagickIsPaletteImage method is:</p>
<pre class="literal-block">unsigned int MagickIsPaletteImage( MagickWand *wand, unsigned int *palette );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>palette:</dt>
<dd><p>Set to True if current image is 256 colors or less,
False if not.</p>
</dd>
</dl>
</section>
</section>
<section id="magicklabelimage">
<h1><a class="toc-backref" href="#id603">MagickLabelImage</a></h1>
<section id="id239">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickLabelImage( MagickWand *wand, const char *label );</pre>
</section>
<section id="id240">
<h2>Description</h2>
<p>MagickLabelImage() adds a label to your image.</p>
<p>The format of the MagickLabelImage method is:</p>
<pre class="literal-block">unsigned int MagickLabelImage( MagickWand *wand, const char *label );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>label:</dt>
<dd><p>The image label.</p>
</dd>
</dl>
</section>
</section>
<section id="magicklevelimage">
<h1><a class="toc-backref" href="#id604">MagickLevelImage</a></h1>
<section id="id241">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickLevelImage( MagickWand *wand, const double black_point, const double gamma,
                               const double white_point );</pre>
</section>
<section id="id242">
<h2>Description</h2>
<p>MagickLevelImage() adjusts the levels of an image by scaling the colors
falling between specified white and black points to the full available
quantum range. The parameters provided represent the black, mid, and white
points. The black point specifies the darkest color in the image. Colors
darker than the black point are set to zero. Mid point specifies a gamma
correction to apply to the image.  White point specifies the lightest color
in the image. Colors brighter than the white point are set to the maximum
quantum value.</p>
<p>The format of the MagickLevelImage method is:</p>
<pre class="literal-block">unsigned int MagickLevelImage( MagickWand *wand, const double black_point, const double gamma,
                               const double white_point );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>black_point:</dt>
<dd><p>The black point.</p>
</dd>
<dt>gamma:</dt>
<dd><p>The gamma.</p>
</dd>
<dt>white_point:</dt>
<dd><p>The white point.</p>
</dd>
</dl>
</section>
</section>
<section id="magicklevelimagechannel">
<h1><a class="toc-backref" href="#id605">MagickLevelImageChannel</a></h1>
<section id="id243">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickLevelImageChannel( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel,
                                      const double black_point, const double gamma,
                                      const double white_point );</pre>
</section>
<section id="id244">
<h2>Description</h2>
<p>MagickLevelImageChannel() adjusts the levels of the specified channel of
the reference image by scaling the colors falling between specified white
and black points to the full available quantum range. The parameters
provided represent the black, mid, and white points. The black point
specifies the darkest color in the image. Colors darker than the black
point are set to zero.  Mid point specifies a gamma correction to apply
to the image.  White point specifies the lightest color in the image.
Colors brighter than the white point are set to the maximum quantum value.</p>
<p>The format of the MagickLevelImageChannel method is:</p>
<pre class="literal-block">unsigned int MagickLevelImageChannel( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel,
                                      const double black_point, const double gamma,
                                      const double white_point );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>channel:</dt>
<dd><p>Identify which channel to level: RedChannel, GreenChannel,
BlueChannel, OpacityChannel, CyanChannel, MagentaChannel, YellowChannel,
BlackChannel.</p>
</dd>
<dt>black_point:</dt>
<dd><p>The black point.</p>
</dd>
<dt>gamma:</dt>
<dd><p>The gamma.</p>
</dd>
<dt>white_point:</dt>
<dd><p>The white point.</p>
</dd>
</dl>
</section>
</section>
<section id="magickmagnifyimage">
<h1><a class="toc-backref" href="#id606">MagickMagnifyImage</a></h1>
<section id="id245">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickMagnifyImage( MagickWand *wand );</pre>
</section>
<section id="id246">
<h2>Description</h2>
<p>MagickMagnifyImage() is a convenience method that scales an image
proportionally to twice its original size.</p>
<p>The format of the MagickMagnifyImage method is:</p>
<pre class="literal-block">unsigned int MagickMagnifyImage( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickmapimage">
<h1><a class="toc-backref" href="#id607">MagickMapImage</a></h1>
<section id="id247">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickMapImage( MagickWand *wand, const MagickWand *map_wand,
                             const unsigned int dither );</pre>
</section>
<section id="id248">
<h2>Description</h2>
<p>MagickMapImage() replaces the colors of an image with the closest color
from a reference image.</p>
<p>The format of the MagickMapImage method is:</p>
<pre class="literal-block">unsigned int MagickMapImage( MagickWand *wand, const MagickWand *map_wand,
                             const unsigned int dither );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>map:</dt>
<dd><p>The map wand.</p>
</dd>
<dt>dither:</dt>
<dd><p>Set this integer value to something other than zero to dither
the mapped image.</p>
</dd>
</dl>
</section>
</section>
<section id="magickmattefloodfillimage">
<h1><a class="toc-backref" href="#id608">MagickMatteFloodfillImage</a></h1>
<section id="id249">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickMatteFloodfillImage( MagickWand *wand, const <a class="reference external" href="../api/types.html#quantum">Quantum</a> opacity,
                                        const double fuzz, const PixelWand *bordercolor,
                                        const long x, const long y );</pre>
</section>
<section id="id250">
<h2>Description</h2>
<p>MagickMatteFloodfillImage() changes the transparency value of any pixel that
matches target and is an immediate neighbor.  If the method
FillToBorderMethod is specified, the transparency value is changed for any
neighbor pixel that does not match the bordercolor member of image.</p>
<p>The format of the MagickMatteFloodfillImage method is:</p>
<pre class="literal-block">unsigned int MagickMatteFloodfillImage( MagickWand *wand, const <a class="reference external" href="../api/types.html#quantum">Quantum</a> opacity,
                                        const double fuzz, const PixelWand *bordercolor,
                                        const long x, const long y );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>opacity:</dt>
<dd><p>The opacity.</p>
</dd>
<dt>fuzz:</dt>
<dd><p>By default target must match a particular pixel color
exactly.  However, in many cases two colors may differ by a small amount.
The fuzz member of image defines how much tolerance is acceptable to
consider two colors as the same.  For example, set fuzz to 10 and the
color red at intensities of 100 and 102 respectively are now interpreted
as the same color for the purposes of the floodfill.</p>
</dd>
<dt>bordercolor:</dt>
<dd><p>The border color pixel wand.</p>
</dd>
<dt>x,y:</dt>
<dd><p>The starting location of the operation.</p>
</dd>
</dl>
</section>
</section>
<section id="magickmedianfilterimage">
<h1><a class="toc-backref" href="#id609">MagickMedianFilterImage</a></h1>
<section id="id251">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickMedianFilterImage( MagickWand *wand, const double radius );</pre>
</section>
<section id="id252">
<h2>Description</h2>
<p>MagickMedianFilterImage() applies a digital filter that improves the quality
of a noisy image.  Each pixel is replaced by the median in a set of
neighboring pixels as defined by radius.</p>
<p>The format of the MagickMedianFilterImage method is:</p>
<pre class="literal-block">unsigned int MagickMedianFilterImage( MagickWand *wand, const double radius );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>radius:</dt>
<dd><p>The radius of the pixel neighborhood.</p>
</dd>
</dl>
</section>
</section>
<section id="magickminifyimage">
<h1><a class="toc-backref" href="#id610">MagickMinifyImage</a></h1>
<section id="id253">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickMinifyImage( MagickWand *wand );</pre>
</section>
<section id="id254">
<h2>Description</h2>
<p>MagickMinifyImage() is a convenience method that scales an image
proportionally to one-half its original size</p>
<p>The format of the MagickMinifyImage method is:</p>
<pre class="literal-block">unsigned int MagickMinifyImage( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickmodulateimage">
<h1><a class="toc-backref" href="#id611">MagickModulateImage</a></h1>
<section id="id255">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickModulateImage( MagickWand *wand, const double brightness,
                                  const double saturation, const double hue );</pre>
</section>
<section id="id256">
<h2>Description</h2>
<p>MagickModulateImage() lets you control the brightness, saturation, and hue
of an image.</p>
<p>The format of the MagickModulateImage method is:</p>
<pre class="literal-block">unsigned int MagickModulateImage( MagickWand *wand, const double brightness,
                                  const double saturation, const double hue );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>brightness:</dt>
<dd><p>The percent change in brighness (-100 thru +100).</p>
</dd>
<dt>saturation:</dt>
<dd><p>The percent change in saturation (-100 thru +100)</p>
</dd>
<dt>hue:</dt>
<dd><p>The percent change in hue (-100 thru +100)</p>
</dd>
</dl>
</section>
</section>
<section id="magickmontageimage">
<h1><a class="toc-backref" href="#id612">MagickMontageImage</a></h1>
<section id="id257">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand MagickMontageImage( MagickWand *wand, const DrawingWand drawing_wand,
                               const char *tile_geometry, const char *thumbnail_geometry,
                               const MontageMode mode, const char *frame );</pre>
</section>
<section id="id258">
<h2>Description</h2>
<p>Use MagickMontageImage() to create a composite image by combining several
separate images. The images are tiled on the composite image with the name
of the image optionally appearing just below the individual tile.</p>
<p>The format of the MagickMontageImage method is:</p>
<pre class="literal-block">MagickWand MagickMontageImage( MagickWand *wand, const DrawingWand drawing_wand,
                               const char *tile_geometry, const char *thumbnail_geometry,
                               const MontageMode mode, const char *frame );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>drawing_wand:</dt>
<dd><p>The drawing wand.  The font name, size, and color are
obtained from this wand.</p>
</dd>
<dt>tile_geometry:</dt>
<dd><p>the number of tiles per row and page (e.g. 6x4+0+0).</p>
</dd>
<dt>thumbnail_geometry:</dt>
<dd><p>Preferred image size and border size of each
thumbnail (e.g. 120x120+4+3&gt;).</p>
</dd>
<dt>mode:</dt>
<dd><p>Thumbnail framing mode: Frame, Unframe, or Concatenate.</p>
</dd>
<dt>frame:</dt>
<dd><p>Surround the image with an ornamental border (e.g. 15x15+3+3).
The frame color is that of the thumbnail's matte color.</p>
</dd>
</dl>
</section>
</section>
<section id="magickmorphimages">
<h1><a class="toc-backref" href="#id613">MagickMorphImages</a></h1>
<section id="id259">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand *MagickMorphImages( MagickWand *wand, const unsigned long number_frames );</pre>
</section>
<section id="id260">
<h2>Description</h2>
<p>MagickMorphImages() method morphs a set of images.  Both the image pixels
and size are linearly interpolated to give the appearance of a
meta-morphosis from one image to the next.</p>
<p>The format of the MagickMorphImages method is:</p>
<pre class="literal-block">MagickWand *MagickMorphImages( MagickWand *wand, const unsigned long number_frames );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>number_frames:</dt>
<dd><p>The number of in-between images to generate.</p>
</dd>
</dl>
</section>
</section>
<section id="magickmosaicimages">
<h1><a class="toc-backref" href="#id614">MagickMosaicImages</a></h1>
<section id="id261">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand *MagickMosaicImages( MagickWand *wand );</pre>
</section>
<section id="id262">
<h2>Description</h2>
<p>MagickMosaicImages() inlays an image sequence to form a single coherent
picture.  It returns a wand with each image in the sequence composited at
the location defined by the page offset of the image.</p>
<p>The format of the MagickMosaicImages method is:</p>
<pre class="literal-block">MagickWand *MagickMosaicImages( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickmotionblurimage">
<h1><a class="toc-backref" href="#id615">MagickMotionBlurImage</a></h1>
<section id="id263">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickMotionBlurImage( MagickWand *wand, const double radius, const double sigma,
                                    const double angle );</pre>
</section>
<section id="id264">
<h2>Description</h2>
<p>MagickMotionBlurImage() simulates motion blur.  We convolve the image with a
Gaussian operator of the given radius and standard deviation (sigma).
For reasonable results, radius should be larger than sigma.  Use a
radius of 0 and MotionBlurImage() selects a suitable radius for you.
Angle gives the angle of the blurring motion.</p>
<p>The format of the MagickMotionBlurImage method is:</p>
<pre class="literal-block">unsigned int MagickMotionBlurImage( MagickWand *wand, const double radius, const double sigma,
                                    const double angle );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>radius:</dt>
<dd><p>The radius of the Gaussian, in pixels, not counting
the center pixel.</p>
</dd>
<dt>sigma:</dt>
<dd><p>The standard deviation of the Gaussian, in pixels.</p>
</dd>
<dt>angle:</dt>
<dd><p>Apply the effect along this angle.</p>
</dd>
</dl>
</section>
</section>
<section id="magicknegateimage">
<h1><a class="toc-backref" href="#id616">MagickNegateImage</a></h1>
<section id="id265">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickNegateImage( MagickWand *wand, const unsigned int gray );</pre>
</section>
<section id="id266">
<h2>Description</h2>
<p>MagickNegateImage() negates the colors in the reference image.  The
Grayscale option means that only grayscale values within the image are
negated.</p>
<p>You can also reduce the influence of a particular channel with a gamma
value of 0.</p>
<p>The format of the MagickNegateImage method is:</p>
<pre class="literal-block">unsigned int MagickNegateImage( MagickWand *wand, const unsigned int gray );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>gray:</dt>
<dd><p>If True, only negate grayscale pixels within the image.</p>
</dd>
</dl>
</section>
</section>
<section id="magicknegateimagechannel">
<h1><a class="toc-backref" href="#id617">MagickNegateImageChannel</a></h1>
<section id="id267">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickNegateImageChannel( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel,
                                       const unsigned int gray );</pre>
</section>
<section id="id268">
<h2>Description</h2>
<p>MagickNegateImageChannel() negates the colors in the specified channel of the
reference image.  The Grayscale option means that only grayscale values
within the image are negated.  Note that the Grayscale option has no
effect for GraphicsMagick.</p>
<p>You can also reduce the influence of a particular channel with a gamma
value of 0.</p>
<p>The format of the MagickNegateImageChannel method is:</p>
<pre class="literal-block">unsigned int MagickNegateImageChannel( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel,
                                       const unsigned int gray );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>channel:</dt>
<dd><p>Identify which channel to extract: RedChannel, GreenChannel,
BlueChannel, OpacityChannel, CyanChannel, MagentaChannel, YellowChannel,
BlackChannel.</p>
</dd>
<dt>gray:</dt>
<dd><p>If True, only negate grayscale pixels within the image.</p>
</dd>
</dl>
</section>
</section>
<section id="magicknextimage">
<h1><a class="toc-backref" href="#id618">MagickNextImage</a></h1>
<section id="id269">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickNextImage( MagickWand *wand );</pre>
</section>
<section id="id270">
<h2>Description</h2>
<p>MagickNextImage() associates the next image in the image list with a magick
wand.  True is returned if the Wand iterated to a next image, or False is
returned if the wand did not iterate to a next image.</p>
<p>The format of the MagickNextImage method is:</p>
<pre class="literal-block">unsigned int MagickNextImage( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magicknormalizeimage">
<h1><a class="toc-backref" href="#id619">MagickNormalizeImage</a></h1>
<section id="id271">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickNormalizeImage( MagickWand *wand );</pre>
</section>
<section id="id272">
<h2>Description</h2>
<p>MagickNormalizeImage() enhances the contrast of a color image by adjusting
the pixels color to span the entire range of colors available</p>
<p>You can also reduce the influence of a particular channel with a gamma
value of 0.</p>
<p>The format of the MagickNormalizeImage method is:</p>
<pre class="literal-block">unsigned int MagickNormalizeImage( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickoilpaintimage">
<h1><a class="toc-backref" href="#id620">MagickOilPaintImage</a></h1>
<section id="id273">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickOilPaintImage( MagickWand *wand, const double radius );</pre>
</section>
<section id="id274">
<h2>Description</h2>
<p>MagickOilPaintImage() applies a special effect filter that simulates an oil
painting.  Each pixel is replaced by the most frequent color occurring
in a circular region defined by radius.</p>
<p>The format of the MagickOilPaintImage method is:</p>
<pre class="literal-block">unsigned int MagickOilPaintImage( MagickWand *wand, const double radius );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>radius:</dt>
<dd><p>The radius of the circular neighborhood.</p>
</dd>
</dl>
</section>
</section>
<section id="magickopaqueimage">
<h1><a class="toc-backref" href="#id621">MagickOpaqueImage</a></h1>
<section id="id275">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickOpaqueImage( MagickWand *wand, const PixelWand *target,
                                const PixelWand *fill, const double fuzz );</pre>
</section>
<section id="id276">
<h2>Description</h2>
<p>MagickOpaqueImage() changes any pixel that matches color with the color
defined by fill.</p>
<p>The format of the MagickOpaqueImage method is:</p>
<pre class="literal-block">unsigned int MagickOpaqueImage( MagickWand *wand, const PixelWand *target,
                                const PixelWand *fill, const double fuzz );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>target:</dt>
<dd><p>Change this target color to the fill color within the image.</p>
</dd>
<dt>fill:</dt>
<dd><p>The fill pixel wand.</p>
</dd>
<dt>fuzz:</dt>
<dd><p>By default target must match a particular pixel color
exactly.  However, in many cases two colors may differ by a small amount.
The fuzz member of image defines how much tolerance is acceptable to
consider two colors as the same.  For example, set fuzz to 10 and the
color red at intensities of 100 and 102 respectively are now interpreted
as the same color for the purposes of the floodfill.</p>
</dd>
</dl>
</section>
</section>
<section id="magickoperatorimagechannel">
<h1><a class="toc-backref" href="#id622">MagickOperatorImageChannel</a></h1>
<section id="id277">
<h2>Synopsis</h2>
<pre class="literal-block">MagickPassFail MagickOperatorImageChannel( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel,
                                           const QuantumOperator quantum_operator,
                                           const double rvalue );</pre>
</section>
<section id="id278">
<h2>Description</h2>
<p>MagickOperatorImageChannel() performs the requested arithmetic,
bitwise-logical, or value operation on the selected channels of
the entire image.  The AllChannels channel option operates on all
color channels whereas the GrayChannel channel option treats the
color channels as a grayscale intensity.</p>
<p>These operations are on the DirectClass pixels of the image and do not
update pixel indexes or colormap.</p>
<p>The format of the MagickOperatorImageChannel method is:</p>
<pre class="literal-block">MagickPassFail MagickOperatorImageChannel( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel,
                                           const QuantumOperator quantum_operator,
                                           const double rvalue );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>channel:</dt>
<dd><p>Channel to operate on (RedChannel, CyanChannel,
GreenChannel, MagentaChannel, BlueChannel, YellowChannel,
OpacityChannel, BlackChannel, MatteChannel, AllChannels,
GrayChannel).  The AllChannels type only updates color
channels.  The GrayChannel type treats the color channels
as if they represent an intensity.</p>
</dd>
<dt>quantum_operator:</dt>
<dd><p>Operator to use (AddQuantumOp,AndQuantumOp,
AssignQuantumOp, DepthQuantumOp, DivideQuantumOp, GammaQuantumOp,
LShiftQuantumOp, MultiplyQuantumOp,  NegateQuantumOp,
NoiseGaussianQuantumOp, NoiseImpulseQuantumOp,
NoiseLaplacianQuantumOp, NoiseMultiplicativeQuantumOp,
NoisePoissonQuantumOp, NoiseRandomQuantumOp, NoiseUniformQuantumOp,
OrQuantumOp, RShiftQuantumOp, SubtractQuantumOp,
ThresholdBlackQuantumOp, ThresholdQuantumOp, ThresholdWhiteQuantumOp,
ThresholdBlackNegateQuantumOp, ThresholdWhiteNegateQuantumOp,
XorQuantumOp).</p>
</dd>
<dt>rvalue:</dt>
<dd><p>Operator argument.</p>
</dd>
</dl>
</section>
</section>
<section id="magickpingimage">
<h1><a class="toc-backref" href="#id623">MagickPingImage</a></h1>
<section id="id279">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickPingImage( MagickWand *wand, const char *filename );</pre>
</section>
<section id="id280">
<h2>Description</h2>
<p>MagickPingImage() is like MagickReadImage() except the only valid
information returned is the image width, height, size, and format.  It
is designed to efficiently obtain this information from a file without
reading the entire image sequence into memory.</p>
<p>The format of the MagickPingImage method is:</p>
<pre class="literal-block">unsigned int MagickPingImage( MagickWand *wand, const char *filename );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>filename:</dt>
<dd><p>The image filename.</p>
</dd>
</dl>
</section>
</section>
<section id="magickpreviewimages">
<h1><a class="toc-backref" href="#id624">MagickPreviewImages</a></h1>
<section id="id281">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand *MagickPreviewImages( MagickWand *wand, const PreviewType preview );</pre>
</section>
<section id="id282">
<h2>Description</h2>
<p>MagickPreviewImages() tiles 9 thumbnails of the specified image with an
image processing operation applied at varying strengths.  This is helpful
to quickly pin-point an appropriate parameter for an image processing
operation.</p>
<p>The format of the MagickPreviewImages method is:</p>
<pre class="literal-block">MagickWand *MagickPreviewImages( MagickWand *wand, const PreviewType preview );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>preview:</dt>
<dd><p>The preview type.</p>
</dd>
</dl>
</section>
</section>
<section id="magickpreviousimage">
<h1><a class="toc-backref" href="#id625">MagickPreviousImage</a></h1>
<section id="id283">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickPreviousImage( MagickWand *wand );</pre>
</section>
<section id="id284">
<h2>Description</h2>
<p>MagickPreviousImage() selects the previous image associated with a magick
wand.</p>
<p>The format of the MagickPreviousImage method is:</p>
<pre class="literal-block">unsigned int MagickPreviousImage( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickprofileimage">
<h1><a class="toc-backref" href="#id626">MagickProfileImage</a></h1>
<section id="id285">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickProfileImage( MagickWand *wand, const char *name,
                                 const unsigned char *profile, const size_t length );</pre>
</section>
<section id="id286">
<h2>Description</h2>
<p>Use MagickProfileImage() to add or remove a ICC, IPTC, or generic profile
from an image.  If the profile is NULL, it is removed from the image
otherwise added.  Use a name of '*' and a profile of NULL to remove all
profiles from the image.</p>
<p>The format of the MagickProfileImage method is:</p>
<pre class="literal-block">unsigned int MagickProfileImage( MagickWand *wand, const char *name,
                                 const unsigned char *profile, const size_t length );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>name:</dt>
<dd><p>Name of profile to add or remove: ICC, IPTC, or generic profile.</p>
</dd>
<dt>profile:</dt>
<dd><p>The profile.</p>
</dd>
<dt>length:</dt>
<dd><p>The length of the profile.</p>
</dd>
</dl>
</section>
</section>
<section id="magickquantizeimage">
<h1><a class="toc-backref" href="#id627">MagickQuantizeImage</a></h1>
<section id="id287">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickQuantizeImage( MagickWand *wand, const unsigned long number_colors,
                                  const <a class="reference external" href="../api/types.html#colorspacetype">ColorspaceType</a> colorspace,
                                  const unsigned long treedepth, const unsigned int dither,
                                  const unsigned int measure_error );</pre>
</section>
<section id="id288">
<h2>Description</h2>
<p>MagickQuantizeImage() analyzes the colors within a reference image and
chooses a fixed number of colors to represent the image.  The goal of the
algorithm is to minimize the color difference between the input and output
image while minimizing the processing time.</p>
<p>The format of the MagickQuantizeImage method is:</p>
<pre class="literal-block">unsigned int MagickQuantizeImage( MagickWand *wand, const unsigned long number_colors,
                                  const <a class="reference external" href="../api/types.html#colorspacetype">ColorspaceType</a> colorspace,
                                  const unsigned long treedepth, const unsigned int dither,
                                  const unsigned int measure_error );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>number_colors:</dt>
<dd><p>The number of colors.</p>
</dd>
<dt>colorspace:</dt>
<dd><p>Perform color reduction in this colorspace, typically
RGBColorspace.</p>
</dd>
<dt>treedepth:</dt>
<dd><p>Normally, this integer value is zero or one.  A zero or
one tells Quantize to choose a optimal tree depth of Log4(number_colors).%      A tree of this depth generally allows the best representation of the
reference image with the least amount of memory and the fastest
computational speed.  In some cases, such as an image with low color
dispersion (a few number of colors), a value other than
Log4(number_colors) is required.  To expand the color tree completely,
use a value of 8.</p>
</dd>
<dt>dither:</dt>
<dd><p>A value other than zero distributes the difference between an
original image and the corresponding color reduced algorithm to
neighboring pixels along a Hilbert curve.</p>
</dd>
<dt>measure_error:</dt>
<dd><p>A value other than zero measures the difference between
the original and quantized images.  This difference is the total
quantization error.  The error is computed by summing over all pixels
in an image the distance squared in RGB space between each reference
pixel value and its quantized value.</p>
</dd>
</dl>
</section>
</section>
<section id="magickquantizeimages">
<h1><a class="toc-backref" href="#id628">MagickQuantizeImages</a></h1>
<section id="id289">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickQuantizeImages( MagickWand *wand, const unsigned long number_colors,
                                   const <a class="reference external" href="../api/types.html#colorspacetype">ColorspaceType</a> colorspace,
                                   const unsigned long treedepth, const unsigned int dither,
                                   const unsigned int measure_error );</pre>
</section>
<section id="id290">
<h2>Description</h2>
<p>MagickQuantizeImage() analyzes the colors within a sequence of images and
chooses a fixed number of colors to represent the image.  The goal of the
algorithm is to minimize the color difference between the input and output
image while minimizing the processing time.</p>
<p>The format of the MagickQuantizeImages method is:</p>
<pre class="literal-block">unsigned int MagickQuantizeImages( MagickWand *wand, const unsigned long number_colors,
                                   const <a class="reference external" href="../api/types.html#colorspacetype">ColorspaceType</a> colorspace,
                                   const unsigned long treedepth, const unsigned int dither,
                                   const unsigned int measure_error );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>number_colors:</dt>
<dd><p>The number of colors.</p>
</dd>
<dt>colorspace:</dt>
<dd><p>Perform color reduction in this colorspace, typically
RGBColorspace.</p>
</dd>
<dt>treedepth:</dt>
<dd><p>Normally, this integer value is zero or one.  A zero or
one tells Quantize to choose a optimal tree depth of Log4(number_colors).%      A tree of this depth generally allows the best representation of the
reference image with the least amount of memory and the fastest
computational speed.  In some cases, such as an image with low color
dispersion (a few number of colors), a value other than
Log4(number_colors) is required.  To expand the color tree completely,
use a value of 8.</p>
</dd>
<dt>dither:</dt>
<dd><p>A value other than zero distributes the difference between an
original image and the corresponding color reduced algorithm to
neighboring pixels along a Hilbert curve.</p>
</dd>
<dt>measure_error:</dt>
<dd><p>A value other than zero measures the difference between
the original and quantized images.  This difference is the total
quantization error.  The error is computed by summing over all pixels
in an image the distance squared in RGB space between each reference
pixel value and its quantized value.</p>
</dd>
</dl>
</section>
</section>
<section id="magickqueryfontmetrics">
<h1><a class="toc-backref" href="#id629">MagickQueryFontMetrics</a></h1>
<section id="id291">
<h2>Synopsis</h2>
<pre class="literal-block">double *MagickQueryFontMetrics( MagickWand *wand, const DrawingWand *drawing_wand,
                                const char *text );</pre>
</section>
<section id="id292">
<h2>Description</h2>
<p>MagickQueryFontMetrics() returns a 7 element array representing the
following font metrics:</p>
</section>
<section id="element-description">
<h2>Element Description</h2>
<p>0 character width
1 character height
2 ascender
3 descender
4 text width
5 text height
6 maximum horizontal advance</p>
<p>The format of the MagickQueryFontMetrics method is:</p>
<pre class="literal-block">double *MagickQueryFontMetrics( MagickWand *wand, const DrawingWand *drawing_wand,
                                const char *text );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The Magick wand.</p>
</dd>
<dt>drawing_wand:</dt>
<dd><p>The drawing wand.</p>
</dd>
<dt>text:</dt>
<dd><p>The text.</p>
</dd>
</dl>
</section>
</section>
<section id="magickqueryfonts">
<h1><a class="toc-backref" href="#id630">MagickQueryFonts</a></h1>
<section id="id293">
<h2>Synopsis</h2>
<pre class="literal-block">char ** MagickQueryFonts( const char *pattern, unsigned long *number_fonts );</pre>
</section>
<section id="id294">
<h2>Description</h2>
<p>MagickQueryFonts() returns any font that match the specified pattern.</p>
<p>The format of the MagickQueryFonts function is:</p>
<pre class="literal-block">char ** MagickQueryFonts( const char *pattern, unsigned long *number_fonts );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>pattern:</dt>
<dd><p>Specifies a pointer to a text string containing a pattern.</p>
</dd>
<dt>number_fonts:</dt>
<dd><p>This integer returns the number of fonts in the list.</p>
</dd>
</dl>
</section>
</section>
<section id="magickqueryformats">
<h1><a class="toc-backref" href="#id631">MagickQueryFormats</a></h1>
<section id="id295">
<h2>Synopsis</h2>
<pre class="literal-block">char ** MagickQueryFormats( const char *pattern, unsigned long *number_formats );</pre>
</section>
<section id="id296">
<h2>Description</h2>
<p>MagickQueryFormats() returns any image formats that match the specified
pattern.</p>
<p>The format of the MagickQueryFormats function is:</p>
<pre class="literal-block">char ** MagickQueryFormats( const char *pattern, unsigned long *number_formats );</pre>
<dl class="simple">
<dt>pattern:</dt>
<dd><p>Specifies a pointer to a text string containing a pattern.</p>
</dd>
<dt>number_formats:</dt>
<dd><p>This integer returns the number of image formats in the
list.</p>
</dd>
</dl>
</section>
</section>
<section id="magickradialblurimage">
<h1><a class="toc-backref" href="#id632">MagickRadialBlurImage</a></h1>
<section id="id297">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickRadialBlurImage( MagickWand *wand, const double angle );</pre>
</section>
<section id="id298">
<h2>Description</h2>
<p>MagickRadialBlurImage() radial blurs an image.</p>
<p>The format of the MagickRadialBlurImage method is:</p>
<pre class="literal-block">unsigned int MagickRadialBlurImage( MagickWand *wand, const double angle );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>angle:</dt>
<dd><p>The angle of the blur in degrees.</p>
</dd>
</dl>
</section>
</section>
<section id="magickraiseimage">
<h1><a class="toc-backref" href="#id633">MagickRaiseImage</a></h1>
<section id="id299">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickRaiseImage( MagickWand *wand, const unsigned long width,
                               const unsigned long height, const long x, const long y,
                               const unsigned int raise_flag );</pre>
</section>
<section id="id300">
<h2>Description</h2>
<p>MagickRaiseImage() creates a simulated three-dimensional button-like effect
by lightening and darkening the edges of the image.  Members width and
height of raise_info define the width of the vertical and horizontal
edge of the effect.</p>
<p>The format of the MagickRaiseImage method is:</p>
<pre class="literal-block">unsigned int MagickRaiseImage( MagickWand *wand, const unsigned long width,
                               const unsigned long height, const long x, const long y,
                               const unsigned int raise_flag );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>width,height,x,y:</dt>
<dd><p>Define the dimensions of the area to raise.</p>
</dd>
<dt>raise_flag:</dt>
<dd><p>A value other than zero creates a 3-D raise effect,
otherwise it has a lowered effect.</p>
</dd>
</dl>
</section>
</section>
<section id="magickreadimage">
<h1><a class="toc-backref" href="#id634">MagickReadImage</a></h1>
<section id="id301">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickReadImage( MagickWand *wand, const char *filename );</pre>
</section>
<section id="id302">
<h2>Description</h2>
<p>MagickReadImage() reads an image or image sequence.</p>
<p>The format of the MagickReadImage method is:</p>
<pre class="literal-block">unsigned int MagickReadImage( MagickWand *wand, const char *filename );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>filename:</dt>
<dd><p>The image filename.</p>
</dd>
</dl>
</section>
</section>
<section id="magickreadimageblob">
<h1><a class="toc-backref" href="#id635">MagickReadImageBlob</a></h1>
<section id="id303">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickReadImageBlob( MagickWand *wand, const unsigned char *blob,
                                  const size_t length );</pre>
</section>
<section id="id304">
<h2>Description</h2>
<p>MagickReadImageBlob() reads an image or image sequence from a blob.</p>
<p>The format of the MagickReadImageBlob method is:</p>
<pre class="literal-block">unsigned int MagickReadImageBlob( MagickWand *wand, const unsigned char *blob,
                                  const size_t length );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>blob:</dt>
<dd><p>The blob.</p>
</dd>
<dt>length:</dt>
<dd><p>The blob length.</p>
</dd>
</dl>
</section>
</section>
<section id="magickreadimagefile">
<h1><a class="toc-backref" href="#id636">MagickReadImageFile</a></h1>
<section id="id305">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickReadImageFile( MagickWand *wand, FILE *file );</pre>
</section>
<section id="id306">
<h2>Description</h2>
<p>MagickReadImageFile() reads an image or image sequence from an open file
descriptor.</p>
<p>The format of the MagickReadImageFile method is:</p>
<pre class="literal-block">unsigned int MagickReadImageFile( MagickWand *wand, FILE *file );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>file:</dt>
<dd><p>The file descriptor.</p>
</dd>
</dl>
</section>
</section>
<section id="magickreducenoiseimage">
<h1><a class="toc-backref" href="#id637">MagickReduceNoiseImage</a></h1>
<section id="id307">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickReduceNoiseImage( MagickWand *wand, const double radius );</pre>
</section>
<section id="id308">
<h2>Description</h2>
<p>MagickReduceNoiseImage() smooths the contours of an image while still
preserving edge information.  The algorithm works by replacing each pixel
with its neighbor closest in value.  A neighbor is defined by radius.  Use
a radius of 0 and ReduceNoise() selects a suitable radius for you.</p>
<p>The format of the MagickReduceNoiseImage method is:</p>
<pre class="literal-block">unsigned int MagickReduceNoiseImage( MagickWand *wand, const double radius );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>radius:</dt>
<dd><p>The radius of the pixel neighborhood.</p>
</dd>
</dl>
</section>
</section>
<section id="magickrelinquishmemory">
<h1><a class="toc-backref" href="#id638">MagickRelinquishMemory</a></h1>
<section id="id309">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickRelinquishMemory( void *resource );</pre>
</section>
<section id="id310">
<h2>Description</h2>
<p>MagickRelinquishMemory() relinquishes memory resources returned by such
methods as MagickDescribeImage(), MagickGetException(), etc.</p>
<p>The format of the MagickRelinquishMemory method is:</p>
<pre class="literal-block">unsigned int MagickRelinquishMemory( void *resource );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>resource:</dt>
<dd><p>Relinquish the memory associated with this resource.</p>
</dd>
</dl>
</section>
</section>
<section id="magickremoveimage">
<h1><a class="toc-backref" href="#id639">MagickRemoveImage</a></h1>
<section id="id311">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickRemoveImage( MagickWand *wand );</pre>
</section>
<section id="id312">
<h2>Description</h2>
<p>MagickRemoveImage() removes an image from the image list.</p>
<p>The format of the MagickRemoveImage method is:</p>
<pre class="literal-block">unsigned int MagickRemoveImage( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickremoveimageoption">
<h1><a class="toc-backref" href="#id640">MagickRemoveImageOption</a></h1>
<section id="id313">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickRemoveImageOption( MagickWand *wand, const char *format,
                                      const char *key );</pre>
</section>
<section id="id314">
<h2>Description</h2>
<p>MagickRemoveImageOption() removes an image format-specific option from the
the image (.e.g MagickRemoveImageOption(wand,&quot;jpeg&quot;,&quot;preserve-settings&quot;).</p>
<p>The format of the MagickRemoveImageOption method is:</p>
<pre class="literal-block">unsigned int MagickRemoveImageOption( MagickWand *wand, const char *format,
                                      const char *key );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>format:</dt>
<dd><p>The image format.</p>
</dd>
<dt>key:</dt>
<dd><p>The key.</p>
</dd>
</dl>
</section>
</section>
<section id="magickremoveimageprofile">
<h1><a class="toc-backref" href="#id641">MagickRemoveImageProfile</a></h1>
<section id="id315">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned char *MagickRemoveImageProfile( MagickWand *wand, const char *name,
                                         unsigned long *length );</pre>
</section>
<section id="id316">
<h2>Description</h2>
<p>MagickRemoveImageProfile() removes the named image profile and returns it.</p>
<p>The format of the MagickRemoveImageProfile method is:</p>
<pre class="literal-block">unsigned char *MagickRemoveImageProfile( MagickWand *wand, const char *name,
                                         unsigned long *length );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>name:</dt>
<dd><p>Name of profile to return: ICC, IPTC, or generic profile.</p>
</dd>
<dt>length:</dt>
<dd><p>The length of the profile.</p>
</dd>
</dl>
</section>
</section>
<section id="magickresetiterator">
<h1><a class="toc-backref" href="#id642">MagickResetIterator</a></h1>
<section id="id317">
<h2>Synopsis</h2>
<pre class="literal-block">void MagickResetIterator( MagickWand *wand );</pre>
</section>
<section id="id318">
<h2>Description</h2>
<p>MagickReset() resets the wand iterator.  Use it in conjunction
with MagickNextImage() to iterate over all the images in a wand
container.</p>
<p>The format of the MagickReset method is:</p>
<pre class="literal-block">void MagickResetIterator( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickresampleimage">
<h1><a class="toc-backref" href="#id643">MagickResampleImage</a></h1>
<section id="id319">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickResampleImage( MagickWand *wand, const double x_resolution,
                                  const double y_resolution, const <a class="reference external" href="../api/types.html#filtertype">FilterTypes</a> filter,
                                  const double blur );</pre>
</section>
<section id="id320">
<h2>Description</h2>
<p>MagickResampleImage() resample image to desired resolution.</p>
<p>Bessel   Blackman   Box
Catrom   Cubic      Gaussian
Hanning  Hermite    Lanczos
Mitchell Point      Quandratic
Sinc     Triangle</p>
<p>Most of the filters are FIR (finite impulse response), however, Bessel,
Gaussian, and Sinc are IIR (infinite impulse response).  Bessel and Sinc
are windowed (brought down to zero) with the Blackman filter.</p>
<p>The format of the MagickResampleImage method is:</p>
<pre class="literal-block">unsigned int MagickResampleImage( MagickWand *wand, const double x_resolution,
                                  const double y_resolution, const <a class="reference external" href="../api/types.html#filtertype">FilterTypes</a> filter,
                                  const double blur );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>x_resolution:</dt>
<dd><p>The new image x resolution.</p>
</dd>
<dt>y_resolution:</dt>
<dd><p>The new image y resolution.</p>
</dd>
<dt>filter:</dt>
<dd><p>Image filter to use.</p>
</dd>
<dt>blur:</dt>
<dd><p>The blur factor where &gt; 1 is blurry, &lt; 1 is sharp.</p>
</dd>
</dl>
</section>
</section>
<section id="magickresizeimage">
<h1><a class="toc-backref" href="#id644">MagickResizeImage</a></h1>
<section id="id321">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickResizeImage( MagickWand *wand, const unsigned long columns,
                                const unsigned long rows, const <a class="reference external" href="../api/types.html#filtertype">FilterTypes</a> filter,
                                const double blur );</pre>
</section>
<section id="id322">
<h2>Description</h2>
<p>MagickResizeImage() scales an image to the desired dimensions with one of
these filters:</p>
<p>Bessel   Blackman   Box
Catrom   Cubic      Gaussian
Hanning  Hermite    Lanczos
Mitchell Point      Quandratic
Sinc     Triangle</p>
<p>Most of the filters are FIR (finite impulse response), however, Bessel,
Gaussian, and Sinc are IIR (infinite impulse response).  Bessel and Sinc
are windowed (brought down to zero) with the Blackman filter.</p>
<p>The format of the MagickResizeImage method is:</p>
<pre class="literal-block">unsigned int MagickResizeImage( MagickWand *wand, const unsigned long columns,
                                const unsigned long rows, const <a class="reference external" href="../api/types.html#filtertype">FilterTypes</a> filter,
                                const double blur );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>columns:</dt>
<dd><p>The number of columns in the scaled image.</p>
</dd>
<dt>rows:</dt>
<dd><p>The number of rows in the scaled image.</p>
</dd>
<dt>filter:</dt>
<dd><p>Image filter to use.</p>
</dd>
<dt>blur:</dt>
<dd><p>The blur factor where &gt; 1 is blurry, &lt; 1 is sharp.</p>
</dd>
</dl>
</section>
</section>
<section id="magickrollimage">
<h1><a class="toc-backref" href="#id645">MagickRollImage</a></h1>
<section id="id323">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickRollImage( MagickWand *wand, const long x_offset,
                              const unsigned long y_offset );</pre>
</section>
<section id="id324">
<h2>Description</h2>
<p>MagickRollImage() offsets an image as defined by x_offset and y_offset.</p>
<p>The format of the MagickRollImage method is:</p>
<pre class="literal-block">unsigned int MagickRollImage( MagickWand *wand, const long x_offset,
                              const unsigned long y_offset );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>x_offset:</dt>
<dd><p>The x offset.</p>
</dd>
<dt>y_offset:</dt>
<dd><p>The y offset.</p>
</dd>
</dl>
</section>
</section>
<section id="magickrotateimage">
<h1><a class="toc-backref" href="#id646">MagickRotateImage</a></h1>
<section id="id325">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickRotateImage( MagickWand *wand, const PixelWand *background,
                                const double degrees );</pre>
</section>
<section id="id326">
<h2>Description</h2>
<p>MagickRotateImage() rotates an image the specified number of degrees. Empty
triangles left over from rotating the image are filled with the
background color.</p>
<p>The format of the MagickRotateImage method is:</p>
<pre class="literal-block">unsigned int MagickRotateImage( MagickWand *wand, const PixelWand *background,
                                const double degrees );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>background:</dt>
<dd><p>The background pixel wand.</p>
</dd>
<dt>degrees:</dt>
<dd><p>The number of degrees to rotate the image.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksampleimage">
<h1><a class="toc-backref" href="#id647">MagickSampleImage</a></h1>
<section id="id327">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSampleImage( MagickWand *wand, const unsigned long columns,
                                const unsigned long rows );</pre>
</section>
<section id="id328">
<h2>Description</h2>
<p>MagickSampleImage() scales an image to the desired dimensions with pixel
sampling.  Unlike other scaling methods, this method does not introduce
any additional color into the scaled image.</p>
<p>The format of the MagickSampleImage method is:</p>
<pre class="literal-block">unsigned int MagickSampleImage( MagickWand *wand, const unsigned long columns,
                                const unsigned long rows );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>columns:</dt>
<dd><p>The number of columns in the scaled image.</p>
</dd>
<dt>rows:</dt>
<dd><p>The number of rows in the scaled image.</p>
</dd>
</dl>
</section>
</section>
<section id="magickscaleimage">
<h1><a class="toc-backref" href="#id648">MagickScaleImage</a></h1>
<section id="id329">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickScaleImage( MagickWand *wand, const unsigned long columns,
                               const unsigned long rows );</pre>
</section>
<section id="id330">
<h2>Description</h2>
<p>MagickScaleImage() scales the size of an image to the given dimensions.</p>
<p>The format of the MagickScaleImage method is:</p>
<pre class="literal-block">unsigned int MagickScaleImage( MagickWand *wand, const unsigned long columns,
                               const unsigned long rows );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>columns:</dt>
<dd><p>The number of columns in the scaled image.</p>
</dd>
<dt>rows:</dt>
<dd><p>The number of rows in the scaled image.</p>
</dd>
</dl>
</section>
</section>
<section id="magickseparateimagechannel">
<h1><a class="toc-backref" href="#id649">MagickSeparateImageChannel</a></h1>
<section id="id331">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSeparateImageChannel( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel );</pre>
</section>
<section id="id332">
<h2>Description</h2>
<p>MagickChannelImage() separates a channel from the image and returns a
grayscale image.  A channel is a particular color component of each pixel
in the image.</p>
<p>The format of the MagickChannelImage method is:</p>
<pre class="literal-block">unsigned int MagickSeparateImageChannel( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>channel:</dt>
<dd><p>Identify which channel to extract: RedChannel, GreenChannel,
BlueChannel, OpacityChannel, CyanChannel, MagentaChannel, YellowChannel,
BlackChannel.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetcompressionquality">
<h1><a class="toc-backref" href="#id650">MagickSetCompressionQuality</a></h1>
<section id="id333">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetCompressionQuality( MagickWand *wand, const unsigned long quality );</pre>
</section>
<section id="id334">
<h2>Description</h2>
<p>MagickSetCompressionQuality() sets the image quality factor, which
determines compression options when saving the file.</p>
<p>For the JPEG and MPEG image formats, quality is 0 (lowest image
quality and highest compression) to 100 (best quality but least
effective compression).  The default quality is 75.  Use the
-sampling-factor option to specify the factors for chroma
downsampling.  To use the same quality value as that found by the
JPEG decoder, use the -define jpeg:preserve-settings flag.</p>
<p>For the MIFF image format, and the TIFF format while using ZIP
compression, quality/10 is the zlib compres- sion level, which is 0
(worst but fastest compression) to 9 (best but slowest). It has no
effect on the image appearance, since the compression is always
lossless.</p>
<p>For the JPEG-2000 image format, quality is mapped using a non-linear
equation to the compression ratio required by the Jasper library.
This non-linear equation is intended to loosely approximate the
quality provided by the JPEG v1 format.  The default quality value 75
results in a request for 16:1 compression. The quality value 100
results in a request for non-lossy compres- sion.</p>
<p>For the MNG and PNG image formats, the quality value sets the zlib
compression level (quality / 10) and filter-type (quality % 10).
Compression levels range from 0 (fastest compression) to 100 (best
but slowest).  For compression level 0, the Huffman-only strategy is
used, which is fastest but not necessarily the worst compression.  If
filter-type is 4 or less, the specified filter-type is used for all
scanlines:</p>
<ol class="arabic simple" start="0">
<li><p>none</p></li>
<li><p>sub</p></li>
<li><p>up</p></li>
<li><p>average</p></li>
<li><p>Paeth</p></li>
</ol>
<p>If filter-type is 5, adaptive filtering is used when quality is
greater than 50 and the image does not have a color map, otherwise no
filtering is used.</p>
<p>If filter-type is 6, adaptive filtering with minimum-
sum-of-absolute-values is used.</p>
<p>Only if the output is MNG, if filter-type is 7, the LOCO color
transformation and adaptive filtering with
minimum-sum-of-absolute-values are used.</p>
<p>The default is quality is 75, which means nearly the best compression
with adaptive filtering.  The quality setting has no effect on the
appearance of PNG and MNG images, since the compression is always
lossless.</p>
<p>For further information, see the PNG specification.</p>
<p>When writing a JNG image with transparency, two quality values are
required, one for the main image and one for the grayscale image that
conveys the opacity channel.  These are written as a single integer
equal to the main image quality plus 1000 times the opacity quality.
For example, if you want to use quality 75 for the main image and
quality 90 to compress the opacity data, use -quality 90075.</p>
<p>For the PNM family of formats (PNM, PGM, and PPM) specify a quality
factor of zero in order to obtain the ASCII variant of the
format. Note that -compress none used to be used to trigger ASCII
output but provided the opposite result of what was expected as
compared with other formats.</p>
<p>The format of the MagickSetCompressionQuality method is:</p>
<pre class="literal-block">unsigned int MagickSetCompressionQuality( MagickWand *wand, const unsigned long quality );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>delay:</dt>
<dd><p>The image quality.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetdepth">
<h1><a class="toc-backref" href="#id651">MagickSetDepth</a></h1>
<section id="id335">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetDepth( MagickWand *wand, const size_t depth );</pre>
</section>
<section id="id336">
<h2>Description</h2>
<p>MagickSetDepth() sets the sample depth to be used when reading from a
raw image or a format which requires that the depth be specified in
advance by the user.</p>
<p>The format of the MagickSetDepth method is:</p>
<pre class="literal-block">unsigned int MagickSetDepth( MagickWand *wand, const size_t depth );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>depth:</dt>
<dd><p>The sample depth.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetfilename">
<h1><a class="toc-backref" href="#id652">MagickSetFilename</a></h1>
<section id="id337">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetFilename( MagickWand *wand, const char *filename );</pre>
</section>
<section id="id338">
<h2>Description</h2>
<p>MagickSetFilename() sets the filename before you read or write an image file.</p>
<p>The format of the MagickSetFilename method is:</p>
<pre class="literal-block">unsigned int MagickSetFilename( MagickWand *wand, const char *filename );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>filename:</dt>
<dd><p>The image filename.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetformat">
<h1><a class="toc-backref" href="#id653">MagickSetFormat</a></h1>
<section id="id339">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetFormat( MagickWand *wand, const char *format );</pre>
</section>
<section id="id340">
<h2>Description</h2>
<p>MagickSetFormat() sets the file or blob format (e.g. &quot;BMP&quot;) to be used
when a file or blob is read.  Usually this is not necessary because
GraphicsMagick is able to auto-detect the format based on the file
header (or the file extension), but some formats do not use a unique
header or the selection may be ambigious. Use MagickSetImageFormat()
to set the format to be used when a file or blob is to be written.</p>
<p>The format of the MagickSetFormat method is:</p>
<pre class="literal-block">unsigned int MagickSetFormat( MagickWand *wand, const char *format );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>filename:</dt>
<dd><p>The file or blob format.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimage">
<h1><a class="toc-backref" href="#id654">MagickSetImage</a></h1>
<section id="id341">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImage( MagickWand *wand, const MagickWand *set_wand );</pre>
</section>
<section id="id342">
<h2>Description</h2>
<p>MagickSetImage() replaces the last image returned by MagickSetImageIndex(),
MagickNextImage(), MagickPreviousImage() with the images from the specified
wand.</p>
<p>The format of the MagickSetImage method is:</p>
<pre class="literal-block">unsigned int MagickSetImage( MagickWand *wand, const MagickWand *set_wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>set_wand:</dt>
<dd><p>The set_wand wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimageattribute">
<h1><a class="toc-backref" href="#id655">MagickSetImageAttribute</a></h1>
<section id="id343">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageAttribute( MagickWand *wand, const char *name,
                                      const char *value );</pre>
</section>
<section id="id344">
<h2>Description</h2>
<p>MagickSetImageAttribute sets an image attribute</p>
<p>The format of the MagickSetImageAttribute method is:</p>
<pre class="literal-block">unsigned int MagickSetImageAttribute( MagickWand *wand, const char *name,
                                      const char *value );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>name:</dt>
<dd><p>The name of the attribute</p>
</dd>
<dt>value:</dt>
<dd><p>The value of the attribute</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagebackgroundcolor">
<h1><a class="toc-backref" href="#id656">MagickSetImageBackgroundColor</a></h1>
<section id="id345">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageBackgroundColor( MagickWand *wand, const PixelWand *background );</pre>
</section>
<section id="id346">
<h2>Description</h2>
<p>MagickSetImageBackgroundColor() sets the image background color.</p>
<p>The format of the MagickSetImageBackgroundColor method is:</p>
<pre class="literal-block">unsigned int MagickSetImageBackgroundColor( MagickWand *wand, const PixelWand *background );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>background:</dt>
<dd><p>The background pixel wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimageblueprimary">
<h1><a class="toc-backref" href="#id657">MagickSetImageBluePrimary</a></h1>
<section id="id347">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageBluePrimary( MagickWand *wand, const double x, const double y );</pre>
</section>
<section id="id348">
<h2>Description</h2>
<p>MagickSetImageBluePrimary() sets the image chromaticity blue primary point.</p>
<p>The format of the MagickSetImageBluePrimary method is:</p>
<pre class="literal-block">unsigned int MagickSetImageBluePrimary( MagickWand *wand, const double x, const double y );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>x:</dt>
<dd><p>The blue primary x-point.</p>
</dd>
<dt>y:</dt>
<dd><p>The blue primary y-point.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagebordercolor">
<h1><a class="toc-backref" href="#id658">MagickSetImageBorderColor</a></h1>
<section id="id349">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageBorderColor( MagickWand *wand, const PixelWand *border );</pre>
</section>
<section id="id350">
<h2>Description</h2>
<p>MagickSetImageBorderColor() sets the image border color.</p>
<p>The format of the MagickSetImageBorderColor method is:</p>
<pre class="literal-block">unsigned int MagickSetImageBorderColor( MagickWand *wand, const PixelWand *border );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>border:</dt>
<dd><p>The border pixel wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagecolormapcolor">
<h1><a class="toc-backref" href="#id659">MagickSetImageColormapColor</a></h1>
<section id="id351">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageColormapColor( MagickWand *wand, const unsigned long index,
                                          const PixelWand *color );</pre>
</section>
<section id="id352">
<h2>Description</h2>
<p>MagickSetImageColormapColor() sets the color of the specified colormap
index.</p>
<p>The format of the MagickSetImageColormapColor method is:</p>
<pre class="literal-block">unsigned int MagickSetImageColormapColor( MagickWand *wand, const unsigned long index,
                                          const PixelWand *color );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>index:</dt>
<dd><p>The offset into the image colormap.</p>
</dd>
<dt>color:</dt>
<dd><p>Return the colormap color in this wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagecolorspace">
<h1><a class="toc-backref" href="#id660">MagickSetImageColorspace</a></h1>
<section id="id353">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageColorspace( MagickWand *wand, const <a class="reference external" href="../api/types.html#colorspacetype">ColorspaceType</a> colorspace );</pre>
</section>
<section id="id354">
<h2>Description</h2>
<p>MagickSetImageColorspace() sets the image colorspace.</p>
<p>The format of the MagickSetImageColorspace method is:</p>
<pre class="literal-block">unsigned int MagickSetImageColorspace( MagickWand *wand, const <a class="reference external" href="../api/types.html#colorspacetype">ColorspaceType</a> colorspace );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>colorspace:</dt>
<dd><p>The image colorspace:   UndefinedColorspace, RGBColorspace,
GRAYColorspace, TransparentColorspace, OHTAColorspace, XYZColorspace,
YCbCrColorspace, YCCColorspace, YIQColorspace, YPbPrColorspace,
YPbPrColorspace, YUVColorspace, CMYKColorspace, sRGBColorspace,
HSLColorspace, or HWBColorspace.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagecompose">
<h1><a class="toc-backref" href="#id661">MagickSetImageCompose</a></h1>
<section id="id355">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageCompose( MagickWand *wand, const <a class="reference external" href="../api/types.html#compositeoperator">CompositeOperator</a> compose );</pre>
</section>
<section id="id356">
<h2>Description</h2>
<p>MagickSetImageCompose() sets the image composite operator, useful for
specifying how to composite the image thumbnail when using the
MagickMontageImage() method.</p>
<p>The format of the MagickSetImageCompose method is:</p>
<pre class="literal-block">unsigned int MagickSetImageCompose( MagickWand *wand, const <a class="reference external" href="../api/types.html#compositeoperator">CompositeOperator</a> compose );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>compose:</dt>
<dd><p>The image composite operator.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagecompression">
<h1><a class="toc-backref" href="#id662">MagickSetImageCompression</a></h1>
<section id="id357">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageCompression( MagickWand *wand,
                                        const <a class="reference external" href="../api/types.html#compressiontype">CompressionType</a> compression );</pre>
</section>
<section id="id358">
<h2>Description</h2>
<p>MagickSetImageCompression() sets the image compression.</p>
<p>The format of the MagickSetImageCompression method is:</p>
<pre class="literal-block">unsigned int MagickSetImageCompression( MagickWand *wand,
                                        const <a class="reference external" href="../api/types.html#compressiontype">CompressionType</a> compression );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>compression:</dt>
<dd><p>The image compression type.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagedelay">
<h1><a class="toc-backref" href="#id663">MagickSetImageDelay</a></h1>
<section id="id359">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageDelay( MagickWand *wand, const unsigned long delay );</pre>
</section>
<section id="id360">
<h2>Description</h2>
<p>MagickSetImageDelay() sets the image delay.</p>
<p>The format of the MagickSetImageDelay method is:</p>
<pre class="literal-block">unsigned int MagickSetImageDelay( MagickWand *wand, const unsigned long delay );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>delay:</dt>
<dd><p>The image delay in 1/100th of a second.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagechanneldepth">
<h1><a class="toc-backref" href="#id664">MagickSetImageChannelDepth</a></h1>
<section id="id361">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageChannelDepth( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel,
                                         const unsigned long depth );</pre>
</section>
<section id="id362">
<h2>Description</h2>
<p>MagickSetImageChannelDepth() sets the depth of a particular image channel.</p>
<p>The format of the MagickSetImageChannelDepth method is:</p>
<pre class="literal-block">unsigned int MagickSetImageChannelDepth( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel,
                                         const unsigned long depth );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>channel:</dt>
<dd><p>Identify which channel to extract: RedChannel, GreenChannel,
BlueChannel, OpacityChannel, CyanChannel, MagentaChannel, YellowChannel,
BlackChannel.</p>
</dd>
<dt>depth:</dt>
<dd><p>The image depth in bits.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagedepth">
<h1><a class="toc-backref" href="#id665">MagickSetImageDepth</a></h1>
<section id="id363">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageDepth( MagickWand *wand, const unsigned long depth );</pre>
</section>
<section id="id364">
<h2>Description</h2>
<p>MagickSetImageDepth() sets the image depth.</p>
<p>The format of the MagickSetImageDepth method is:</p>
<pre class="literal-block">unsigned int MagickSetImageDepth( MagickWand *wand, const unsigned long depth );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>depth:</dt>
<dd><p>The image depth in bits: 8, 16, or 32.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagedispose">
<h1><a class="toc-backref" href="#id666">MagickSetImageDispose</a></h1>
<section id="id365">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageDispose( MagickWand *wand, const DisposeType dispose );</pre>
</section>
<section id="id366">
<h2>Description</h2>
<p>MagickSetImageDispose() sets the image disposal method.</p>
<p>The format of the MagickSetImageDispose method is:</p>
<pre class="literal-block">unsigned int MagickSetImageDispose( MagickWand *wand, const DisposeType dispose );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>dispose:</dt>
<dd><p>The image disposeal type.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagefilename">
<h1><a class="toc-backref" href="#id667">MagickSetImageFilename</a></h1>
<section id="id367">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageFilename( MagickWand *wand, const char *filename );</pre>
</section>
<section id="id368">
<h2>Description</h2>
<p>MagickSetImageFilename() sets the filename of a particular image in a
sequence.</p>
<p>The format of the MagickSetImageFilename method is:</p>
<pre class="literal-block">unsigned int MagickSetImageFilename( MagickWand *wand, const char *filename );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>filename:</dt>
<dd><p>The image filename.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimageformat">
<h1><a class="toc-backref" href="#id668">MagickSetImageFormat</a></h1>
<section id="id369">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageFormat( MagickWand *wand, const char *format );</pre>
</section>
<section id="id370">
<h2>Description</h2>
<p>MagickSetImageFormat() sets the format of a particular image in a
sequence.  The format is designated by a magick string (e.g. &quot;GIF&quot;).</p>
<p>The format of the MagickSetImageFormat method is:</p>
<pre class="literal-block">unsigned int MagickSetImageFormat( MagickWand *wand, const char *format );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>magick:</dt>
<dd><p>The image format.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagefuzz">
<h1><a class="toc-backref" href="#id669">MagickSetImageFuzz</a></h1>
<section id="id371">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageFuzz( MagickWand *wand, const double fuzz );</pre>
</section>
<section id="id372">
<h2>Description</h2>
<p>MagickSetImageFuzz() sets the color comparison fuzz factor.  Colors
closer than the fuzz factor are considered to be the same when comparing
colors.  Note that some other functions such as MagickColorFloodfillImage()
implicitly set this value.</p>
<p>The format of the MagickSetImageFuzz method is:</p>
<pre class="literal-block">unsigned int MagickSetImageFuzz( MagickWand *wand, const double fuzz );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>fuzz:</dt>
<dd><p>The color comparison fuzz factor</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagegamma">
<h1><a class="toc-backref" href="#id670">MagickSetImageGamma</a></h1>
<section id="id373">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageGamma( MagickWand *wand, const double gamma );</pre>
</section>
<section id="id374">
<h2>Description</h2>
<p>MagickSetImageGamma() sets the image gamma.</p>
<p>The format of the MagickSetImageGamma method is:</p>
<pre class="literal-block">unsigned int MagickSetImageGamma( MagickWand *wand, const double gamma );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>gamma:</dt>
<dd><p>The image gamma.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagegeometry">
<h1><a class="toc-backref" href="#id671">MagickSetImageGeometry</a></h1>
<section id="id375">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageGeometry( MagickWand *wand, const char *geometry );</pre>
</section>
<section id="id376">
<h2>Description</h2>
<p>MagickSetImageGeometry() sets the image geometry string.</p>
<p>The format of the MagickSetImageGeometry method is:</p>
<pre class="literal-block">unsigned int MagickSetImageGeometry( MagickWand *wand, const char *geometry );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>geometry:</dt>
<dd><p>The image geometry.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagegravity">
<h1><a class="toc-backref" href="#id672">MagickSetImageGravity</a></h1>
<section id="id377">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageGravity( MagickWand *wand, const <a class="reference external" href="../api/types.html#gravitytype">GravityType</a> );</pre>
</section>
<section id="id378">
<h2>Description</h2>
<p>MagickSetImageGravity() sets the image gravity.  This is used
when evaluating regions defined by a geometry and the image
dimensions.  It may be used in conjunction with operations which
use a geometry parameter to adjust the x, y parameters of the
final operation. Gravity is used in composition to determine where
the image should be placed within the defined geometry region.
It may be used with montage to effect placement of the image within
the tile.</p>
<p>The format of the MagickSetImageGravity method is:</p>
<pre class="literal-block">unsigned int MagickSetImageGravity( MagickWand *wand, const <a class="reference external" href="../api/types.html#gravitytype">GravityType</a> );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>gravity:</dt>
<dd><p>The image gravity.  Available values are ForgetGravity,
NorthWestGravity, NorthGravity, NorthEastGravity, WestGravity,
CenterGravity, EastGravity, SouthWestGravity, SouthGravity,
SouthEastGravity, and StaticGravity</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagegreenprimary">
<h1><a class="toc-backref" href="#id673">MagickSetImageGreenPrimary</a></h1>
<section id="id379">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageGreenPrimary( MagickWand *wand, const double x, const double y );</pre>
</section>
<section id="id380">
<h2>Description</h2>
<p>MagickSetImageGreenPrimary() sets the image chromaticity green primary
point.</p>
<p>The format of the MagickSetImageGreenPrimary method is:</p>
<pre class="literal-block">unsigned int MagickSetImageGreenPrimary( MagickWand *wand, const double x, const double y );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>x:</dt>
<dd><p>The green primary x-point.</p>
</dd>
<dt>y:</dt>
<dd><p>The green primary y-point.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimageindex">
<h1><a class="toc-backref" href="#id674">MagickSetImageIndex</a></h1>
<section id="id381">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageIndex( MagickWand *wand, const long index );</pre>
</section>
<section id="id382">
<h2>Description</h2>
<p>MagickSetImageIndex() set the current image to the position of the list
specified with the index parameter.</p>
<p>The format of the MagickSetImageIndex method is:</p>
<pre class="literal-block">unsigned int MagickSetImageIndex( MagickWand *wand, const long index );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>index:</dt>
<dd><p>The scene number.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimageinterlacescheme">
<h1><a class="toc-backref" href="#id675">MagickSetImageInterlaceScheme</a></h1>
<section id="id383">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageInterlaceScheme( MagickWand *wand,
                                            const <a class="reference external" href="../api/types.html#interlacetype">InterlaceType</a> interlace_scheme );</pre>
</section>
<section id="id384">
<h2>Description</h2>
<p>MagickSetImageInterlaceScheme() sets the image interlace scheme.  Please
use SetInterlaceScheme() instead to change the interlace scheme used when
writing the image.</p>
<p>The format of the MagickSetImageInterlaceScheme method is:</p>
<pre class="literal-block">unsigned int MagickSetImageInterlaceScheme( MagickWand *wand,
                                            const <a class="reference external" href="../api/types.html#interlacetype">InterlaceType</a> interlace_scheme );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>interlace_scheme:</dt>
<dd><p>The image interlace scheme: NoInterlace, LineInterlace,
PlaneInterlace, PartitionInterlace.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimageiterations">
<h1><a class="toc-backref" href="#id676">MagickSetImageIterations</a></h1>
<section id="id385">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageIterations( MagickWand *wand, const unsigned long iterations );</pre>
</section>
<section id="id386">
<h2>Description</h2>
<p>MagickSetImageIterations() sets the image iterations.</p>
<p>The format of the MagickSetImageIterations method is:</p>
<pre class="literal-block">unsigned int MagickSetImageIterations( MagickWand *wand, const unsigned long iterations );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>delay:</dt>
<dd><p>The image delay in 1/100th of a second.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagematte">
<h1><a class="toc-backref" href="#id677">MagickSetImageMatte</a></h1>
<section id="id387">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageMatte( MagickWand *wand, const unsigned int matte );</pre>
</section>
<section id="id388">
<h2>Description</h2>
<p>MagickSetImageMatte() sets the image matte flag.  The image opacity
(inverse of transparency) channel is enabled if the matte flag is
True.</p>
<p>The format of the MagickSetImageMatte method is:</p>
<pre class="literal-block">unsigned int MagickSetImageMatte( MagickWand *wand, const unsigned int matte );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>matte:</dt>
<dd><p>The image matte.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagemattecolor">
<h1><a class="toc-backref" href="#id678">MagickSetImageMatteColor</a></h1>
<section id="id389">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageMatteColor( MagickWand *wand, const PixelWand *matte );</pre>
</section>
<section id="id390">
<h2>Description</h2>
<p>MagickSetImageMatteColor() sets the image matte color.</p>
<p>The format of the MagickSetImageMatteColor method is:</p>
<pre class="literal-block">unsigned int MagickSetImageMatteColor( MagickWand *wand, const PixelWand *matte );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>matte:</dt>
<dd><p>The matte pixel wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimageoption">
<h1><a class="toc-backref" href="#id679">MagickSetImageOption</a></h1>
<section id="id391">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageOption( MagickWand *wand, const char *format, const char *key,
                                   const char *value );</pre>
</section>
<section id="id392">
<h2>Description</h2>
<p>MagickSetImageOption() associates one or options with a particular image
format (.e.g MagickSetImageOption(wand,&quot;jpeg&quot;,&quot;preserve-settings&quot;,&quot;true&quot;).</p>
<p>The format of the MagickSetImageOption method is:</p>
<pre class="literal-block">unsigned int MagickSetImageOption( MagickWand *wand, const char *format, const char *key,
                                   const char *value );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>format:</dt>
<dd><p>The image format.</p>
</dd>
<dt>key:</dt>
<dd><p>The key.</p>
</dd>
<dt>value:</dt>
<dd><p>The value.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimageorientation">
<h1><a class="toc-backref" href="#id680">MagickSetImageOrientation</a></h1>
<section id="id393">
<h2>Synopsis</h2>
<pre class="literal-block">MagickSetImageOrientation( MagickWand *wand, OrientationType new_orientation );</pre>
</section>
<section id="id394">
<h2>Description</h2>
<p>MagickSetImageOrientation() sets the internal image orientation type.
The EXIF orientation tag will be updated if present.</p>
<p>The format of the MagickSetImageOrientation method is:</p>
<pre class="literal-block">MagickSetImageOrientation( MagickWand *wand, OrientationType new_orientation );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>new_orientation:</dt>
<dd><p>The new orientation of the image. One of:</p>
</dd>
</dl>
<p>UndefinedOrientation    Image orientation not specified.
TopLeftOrientation      Left to right and Top to bottom.
TopRightOrientation     Right to left  and Top to bottom.
BottomRightOrientation  Right to left and Bottom to top.
BottomLeftOrientation   Left to right and Bottom to top.
LeftTopOrientation      Top to bottom and Left to right.
RightTopOrientation     Top to bottom and Right to left.
RightBottomOrientation  Bottom to top and Right to left.
LeftBottomOrientation   Bottom to top and Left to right.</p>
<p>Returns True on success, False otherwise.</p>
</section>
</section>
<section id="magicksetimagepage">
<h1><a class="toc-backref" href="#id681">MagickSetImagePage</a></h1>
<section id="id395">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImagePage( MagickWand *wand, const unsigned long width,
                                 const unsigned long height, const long x, const long y );</pre>
</section>
<section id="id396">
<h2>Description</h2>
<p>MagickSetImagePage() sets the image page size and offset used when
placing (e.g. compositing) the image.  Pass all zeros for the
default placement.</p>
<p>The format of the MagickSetImagePage method is:</p>
<pre class="literal-block">unsigned int MagickSetImagePage( MagickWand *wand, const unsigned long width,
                                 const unsigned long height, const long x, const long y );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>width, height:</dt>
<dd><p>The region size.</p>
</dd>
<dt>x, y:</dt>
<dd><p>Offset (from top left) on base canvas image on
which to composite image data.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagepixels">
<h1><a class="toc-backref" href="#id682">MagickSetImagePixels</a></h1>
<section id="id397">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImagePixels( MagickWand *wand, const long x_offset, const long y_offset,
                                   const unsigned long columns, const unsigned long rows,
                                   const char *map, const <a class="reference external" href="../api/types.html#storagetype">StorageType</a> storage,
                                   unsigned char *pixels );</pre>
</section>
<section id="id398">
<h2>Description</h2>
<p>MagickSetImagePixels() accepts pixel data and stores it in the image at the
location you specify.  The method returns False on success, otherwise True
if an error is encountered.  The pixel data can be either char, short int,
int, long, float, or double in the order specified by map.</p>
<p>Suppose you want to upload the first scanline of a 640x480 image from
character data in red-green-blue order:</p>
<p>MagickSetImagePixels(wand,0,0,0,640,1,&quot;RGB&quot;,CharPixel,pixels);</p>
<p>The API user is responsible for assuring that pixels in the entire
image are initialized properly.  If non-opaque pixels are to be
supported (e.g. &quot;RGBA&quot;) but the image does not already have an
opacity channel (e.g. MagickGetImageMatte() returns False), please use
MagickSetImageMatte() to set Matte true, and then assure that the
opacity channel is initialized for all of the pixels.  This is necessary
even if the region specified to MagickSetImagePixels() includes the
entire image.</p>
<p>The format of the MagickSetImagePixels method is:</p>
<pre class="literal-block">unsigned int MagickSetImagePixels( MagickWand *wand, const long x_offset, const long y_offset,
                                   const unsigned long columns, const unsigned long rows,
                                   const char *map, const <a class="reference external" href="../api/types.html#storagetype">StorageType</a> storage,
                                   unsigned char *pixels );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>x_offset, y_offset:</dt>
<dd><p>Offset (from top left) on base canvas image on
which to composite image data.</p>
</dd>
<dt>columns, rows:</dt>
<dd><p>Dimensions of image.</p>
</dd>
<dt>map:</dt>
<dd><p>This string reflects the expected ordering of the pixel array.
It can be any combination or order of R = red, G = green, B = blue,
A = alpha (same as Transparency), O = Opacity, T = Transparency,
C = cyan, Y = yellow, M = magenta, K = black, or I = intensity
(for grayscale). Specify &quot;P&quot; = pad, to skip over a quantum which is
intentionally ignored. Creation of an alpha channel for CMYK images
is currently not supported.</p>
</dd>
<dt>storage:</dt>
<dd><p>Define the data type of the pixels.  Float and double types are
expected to be normalized [0..1] otherwise [0..MaxRGB].  Choose from
these types: CharPixel, ShortPixel, IntegerPixel, LongPixel, FloatPixel,
or DoublePixel.</p>
</dd>
<dt>pixels:</dt>
<dd><p>This array of values contain the pixel components as defined by
map and type.  You must preallocate this array where the expected
length varies depending on the values of width, height, map, and type.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimageprofile">
<h1><a class="toc-backref" href="#id683">MagickSetImageProfile</a></h1>
<section id="id399">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageProfile( MagickWand *wand, const char *name,
                                    const unsigned char *profile,
                                    const unsigned long length );</pre>
</section>
<section id="id400">
<h2>Description</h2>
<p>MagickSetImageProfile() adds a named profile to the magick wand.  If a
profile with the same name already exists, it is replaced.  This method
differs from the MagickProfileImage() method in that it does not apply any
CMS color profiles.</p>
<p>The format of the MagickSetImageProfile method is:</p>
<pre class="literal-block">unsigned int MagickSetImageProfile( MagickWand *wand, const char *name,
                                    const unsigned char *profile,
                                    const unsigned long length );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>name:</dt>
<dd><p>Name of profile to add or remove: ICC, IPTC, or generic profile.</p>
</dd>
<dt>profile:</dt>
<dd><p>The profile.</p>
</dd>
<dt>length:</dt>
<dd><p>The length of the profile.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimageredprimary">
<h1><a class="toc-backref" href="#id684">MagickSetImageRedPrimary</a></h1>
<section id="id401">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageRedPrimary( MagickWand *wand, const double x, const double y );</pre>
</section>
<section id="id402">
<h2>Description</h2>
<p>MagickSetImageRedPrimary() sets the image chromaticity red primary point.</p>
<p>The format of the MagickSetImageRedPrimary method is:</p>
<pre class="literal-block">unsigned int MagickSetImageRedPrimary( MagickWand *wand, const double x, const double y );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>x:</dt>
<dd><p>The red primary x-point.</p>
</dd>
<dt>y:</dt>
<dd><p>The red primary y-point.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagerenderingintent">
<h1><a class="toc-backref" href="#id685">MagickSetImageRenderingIntent</a></h1>
<section id="id403">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageRenderingIntent( MagickWand *wand,
                                            const <a class="reference external" href="../api/types.html#renderingintent">RenderingIntent</a> rendering_intent );</pre>
</section>
<section id="id404">
<h2>Description</h2>
<p>MagickSetImageRenderingIntent() sets the image rendering intent.</p>
<p>The format of the MagickSetImageRenderingIntent method is:</p>
<pre class="literal-block">unsigned int MagickSetImageRenderingIntent( MagickWand *wand,
                                            const <a class="reference external" href="../api/types.html#renderingintent">RenderingIntent</a> rendering_intent );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>rendering_intent:</dt>
<dd><p>The image rendering intent: UndefinedIntent,
SaturationIntent, PerceptualIntent, AbsoluteIntent, or RelativeIntent.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimageresolution">
<h1><a class="toc-backref" href="#id686">MagickSetImageResolution</a></h1>
<section id="id405">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageResolution( MagickWand *wand, const double x_resolution,
                                       const doubtl y_resolution );</pre>
</section>
<section id="id406">
<h2>Description</h2>
<p>MagickSetImageResolution() sets the image resolution.</p>
<p>The format of the MagickSetImageResolution method is:</p>
<pre class="literal-block">unsigned int MagickSetImageResolution( MagickWand *wand, const double x_resolution,
                                       const doubtl y_resolution );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>x_resolution:</dt>
<dd><p>The image x resolution.</p>
</dd>
<dt>y_resolution:</dt>
<dd><p>The image y resolution.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagescene">
<h1><a class="toc-backref" href="#id687">MagickSetImageScene</a></h1>
<section id="id407">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageScene( MagickWand *wand, const unsigned long scene );</pre>
</section>
<section id="id408">
<h2>Description</h2>
<p>MagickSetImageScene() sets the image scene.</p>
<p>The format of the MagickSetImageScene method is:</p>
<pre class="literal-block">unsigned int MagickSetImageScene( MagickWand *wand, const unsigned long scene );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>delay:</dt>
<dd><p>The image scene number.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagetype">
<h1><a class="toc-backref" href="#id688">MagickSetImageType</a></h1>
<section id="id409">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageType( MagickWand *wand, const <a class="reference external" href="../api/types.html#imagetype">ImageType</a> image_type );</pre>
</section>
<section id="id410">
<h2>Description</h2>
<p>MagickSetImageType() sets the image type.</p>
<p>The format of the MagickSetImageType method is:</p>
<pre class="literal-block">unsigned int MagickSetImageType( MagickWand *wand, const <a class="reference external" href="../api/types.html#imagetype">ImageType</a> image_type );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>image_type:</dt>
<dd><p>The image type:   UndefinedType, BilevelType, GrayscaleType,
GrayscaleMatteType, PaletteType, PaletteMatteType, TrueColorType,
TrueColorMatteType, ColorSeparationType, ColorSeparationMatteType,
or OptimizeType.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagesavedtype">
<h1><a class="toc-backref" href="#id689">MagickSetImageSavedType</a></h1>
<section id="id411">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageSavedType( MagickWand *wand, const <a class="reference external" href="../api/types.html#imagetype">ImageType</a> image_type );</pre>
</section>
<section id="id412">
<h2>Description</h2>
<p>MagickSetImageSavedType() sets the image type that will be used when the
image is saved.</p>
<p>The format of the MagickSetImageSavedType method is:</p>
<pre class="literal-block">unsigned int MagickSetImageSavedType( MagickWand *wand, const <a class="reference external" href="../api/types.html#imagetype">ImageType</a> image_type );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>image_type:</dt>
<dd><p>The image type:   UndefinedType, BilevelType, GrayscaleType,
GrayscaleMatteType, PaletteType, PaletteMatteType, TrueColorType,
TrueColorMatteType, ColorSeparationType, ColorSeparationMatteType,
or OptimizeType.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimageunits">
<h1><a class="toc-backref" href="#id690">MagickSetImageUnits</a></h1>
<section id="id413">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageUnits( MagickWand *wand, const <a class="reference external" href="../api/types.html#resolutiontype">ResolutionType</a> units );</pre>
</section>
<section id="id414">
<h2>Description</h2>
<p>MagickSetImageUnits() sets the image units of resolution.</p>
<p>The format of the MagickSetImageUnits method is:</p>
<pre class="literal-block">unsigned int MagickSetImageUnits( MagickWand *wand, const <a class="reference external" href="../api/types.html#resolutiontype">ResolutionType</a> units );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>units:</dt>
<dd><p>The image units of resolution : Undefinedresolution,
PixelsPerInchResolution, or PixelsPerCentimeterResolution.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagevirtualpixelmethod">
<h1><a class="toc-backref" href="#id691">MagickSetImageVirtualPixelMethod</a></h1>
<section id="id415">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageVirtualPixelMethod( MagickWand *wand,
                                               const <a class="reference external" href="../api/types.html#virtualpixelmethod">VirtualPixelMethod</a> method );</pre>
</section>
<section id="id416">
<h2>Description</h2>
<p>MagickSetImageVirtualPixelMethod() sets the image virtual pixel method.</p>
<p>The format of the MagickSetImageVirtualPixelMethod method is:</p>
<pre class="literal-block">unsigned int MagickSetImageVirtualPixelMethod( MagickWand *wand,
                                               const <a class="reference external" href="../api/types.html#virtualpixelmethod">VirtualPixelMethod</a> method );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>method:</dt>
<dd><p>The image virtual pixel method : UndefinedVirtualPixelMethod,
ConstantVirtualPixelMethod,  EdgeVirtualPixelMethod,
MirrorVirtualPixelMethod, or TileVirtualPixelMethod.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetinterlacescheme">
<h1><a class="toc-backref" href="#id692">MagickSetInterlaceScheme</a></h1>
<section id="id417">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetInterlaceScheme( MagickWand *wand,
                                       const <a class="reference external" href="../api/types.html#interlacetype">InterlaceType</a> interlace_scheme );</pre>
</section>
<section id="id418">
<h2>Description</h2>
<p>MagickSetInterlaceScheme() sets the interlace scheme used when writing
the image.</p>
<p>The format of the MagickSetInterlaceScheme method is:</p>
<pre class="literal-block">unsigned int MagickSetInterlaceScheme( MagickWand *wand,
                                       const <a class="reference external" href="../api/types.html#interlacetype">InterlaceType</a> interlace_scheme );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>interlace_scheme:</dt>
<dd><p>The image interlace scheme: NoInterlace, LineInterlace,
PlaneInterlace, PartitionInterlace.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetresolution">
<h1><a class="toc-backref" href="#id693">MagickSetResolution</a></h1>
<section id="id419">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetResolution( MagickWand *wand, const double x_resolution,
                                  const double y_resolution );</pre>
</section>
<section id="id420">
<h2>Description</h2>
<p>MagickSetResolution() sets the resolution (density) of the magick wand.
Set it before you read an EPS, PDF, or Postscript file in order to
influence the size of the returned image, or after an image has already
been created to influence the rendered image size when used with
typesetting software.</p>
<p>Also see MagickSetResolutionUnits() which specifies the units to use for
the image resolution.</p>
<p>The format of the MagickSetResolution method is:</p>
<pre class="literal-block">unsigned int MagickSetResolution( MagickWand *wand, const double x_resolution,
                                  const double y_resolution );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>x_resolution:</dt>
<dd><p>The horizontal resolution</p>
</dd>
<dt>y_resolution:</dt>
<dd><p>The vertical reesolution</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetresolutionunits">
<h1><a class="toc-backref" href="#id694">MagickSetResolutionUnits</a></h1>
<section id="id421">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetResolutionUnits( MagickWand *wand, const <a class="reference external" href="../api/types.html#resolutiontype">ResolutionType</a> units );</pre>
</section>
<section id="id422">
<h2>Description</h2>
<p>MagickSetResolutionUnits() sets the resolution units of the magick wand.
It should be used in conjunction with MagickSetResolution().
This method works both before and after an image has been read.</p>
<p>Also see MagickSetImageUnits() which specifies the units which apply to
the image resolution setting after an image has been read.</p>
<p>The format of the MagickSetResolutionUnits method is:</p>
<pre class="literal-block">unsigned int MagickSetResolutionUnits( MagickWand *wand, const <a class="reference external" href="../api/types.html#resolutiontype">ResolutionType</a> units );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>units:</dt>
<dd><p>The image units of resolution : Undefinedresolution,
PixelsPerInchResolution, or PixelsPerCentimeterResolution.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetresourcelimit">
<h1><a class="toc-backref" href="#id695">MagickSetResourceLimit</a></h1>
<section id="id423">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetResourceLimit( const <a class="reference external" href="../api/types.html#resourcetype">ResourceType</a> type, const unsigned long *limit );</pre>
</section>
<section id="id424">
<h2>Description</h2>
<p>MagickSetResourceLimit() sets the limit for a particular resource in
megabytes.</p>
<p>The format of the MagickSetResourceLimit method is:</p>
<pre class="literal-block">unsigned int MagickSetResourceLimit( const <a class="reference external" href="../api/types.html#resourcetype">ResourceType</a> type, const unsigned long *limit );</pre>
<dl class="simple">
<dt>type:</dt>
<dd><p>The type of resource: DiskResource, FileResource, MapResource,
MemoryResource, PixelsResource, ThreadsResource, WidthResource,
HeightResource.</p>
</dd>
</dl>
<p>o The maximum limit for the resource.</p>
</section>
</section>
<section id="magicksetsamplingfactors">
<h1><a class="toc-backref" href="#id696">MagickSetSamplingFactors</a></h1>
<section id="id425">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetSamplingFactors( MagickWand *wand, const unsigned long number_factors,
                                       const double *sampling_factors );</pre>
</section>
<section id="id426">
<h2>Description</h2>
<p>MagickSetSamplingFactors() sets the image sampling factors.</p>
<p>The format of the MagickSetSamplingFactors method is:</p>
<pre class="literal-block">unsigned int MagickSetSamplingFactors( MagickWand *wand, const unsigned long number_factors,
                                       const double *sampling_factors );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>number_factors:</dt>
<dd><p>The number of factors.  This value should be evenly
divisible by two.</p>
</dd>
<dt>sampling_factors:</dt>
<dd><p>An array of doubles representing the sampling factor
for each color component (in RGB order).  Two double values must be
provided for each color component.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetsize">
<h1><a class="toc-backref" href="#id697">MagickSetSize</a></h1>
<section id="id427">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetSize( MagickWand *wand, const unsigned long columns,
                            const unsigned long rows );</pre>
</section>
<section id="id428">
<h2>Description</h2>
<p>MagickSetSize() sets the size of the magick wand.  Set it before you
read a raw image format such as RGB, GRAY, or CMYK.</p>
<p>The format of the MagickSetSize method is:</p>
<pre class="literal-block">unsigned int MagickSetSize( MagickWand *wand, const unsigned long columns,
                            const unsigned long rows );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>columns:</dt>
<dd><p>The width in pixels.</p>
</dd>
<dt>height:</dt>
<dd><p>The height in pixels.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetimagewhitepoint">
<h1><a class="toc-backref" href="#id698">MagickSetImageWhitePoint</a></h1>
<section id="id429">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetImageWhitePoint( MagickWand *wand, const double x, const double y );</pre>
</section>
<section id="id430">
<h2>Description</h2>
<p>MagickSetImageWhitePoint() sets the image chromaticity white point.</p>
<p>The format of the MagickSetImageWhitePoint method is:</p>
<pre class="literal-block">unsigned int MagickSetImageWhitePoint( MagickWand *wand, const double x, const double y );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>x:</dt>
<dd><p>The white x-point.</p>
</dd>
<dt>y:</dt>
<dd><p>The white y-point.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksetpassphrase">
<h1><a class="toc-backref" href="#id699">MagickSetPassphrase</a></h1>
<section id="id431">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSetPassphrase( MagickWand *wand, const char *passphrase );</pre>
</section>
<section id="id432">
<h2>Description</h2>
<p>MagickSetPassphrase() sets the passphrase.</p>
<p>The format of the MagickSetPassphrase method is:</p>
<pre class="literal-block">unsigned int MagickSetPassphrase( MagickWand *wand, const char *passphrase );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>passphrase:</dt>
<dd><p>The passphrase.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksharpenimage">
<h1><a class="toc-backref" href="#id700">MagickSharpenImage</a></h1>
<section id="id433">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSharpenImage( MagickWand *wand, const double radius, const double sigma );</pre>
</section>
<section id="id434">
<h2>Description</h2>
<p>MagickSharpenImage() sharpens an image.  We convolve the image with a Gaussian
operator of the given radius and standard deviation (sigma).
For reasonable results, the radius should be larger than sigma.  Use a
radius of 0 and SharpenImage() selects a suitable radius for you.</p>
<p>The format of the MagickSharpenImage method is:</p>
<pre class="literal-block">unsigned int MagickSharpenImage( MagickWand *wand, const double radius, const double sigma );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>radius:</dt>
<dd><p>The radius of the Gaussian, in pixels, not counting the center
pixel.</p>
</dd>
<dt>sigma:</dt>
<dd><p>The standard deviation of the Gaussian, in pixels.</p>
</dd>
</dl>
</section>
</section>
<section id="magickshaveimage">
<h1><a class="toc-backref" href="#id701">MagickShaveImage</a></h1>
<section id="id435">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickShaveImage( MagickWand *wand, const unsigned long columns,
                               const unsigned long rows );</pre>
</section>
<section id="id436">
<h2>Description</h2>
<p>MagickShaveImage() shaves pixels from the image edges.  It allocates the
memory necessary for the new Image structure and returns a pointer to the
new image.</p>
<p>The format of the MagickShaveImage method is:</p>
<pre class="literal-block">unsigned int MagickShaveImage( MagickWand *wand, const unsigned long columns,
                               const unsigned long rows );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>columns:</dt>
<dd><p>The number of columns in the scaled image.</p>
</dd>
<dt>rows:</dt>
<dd><p>The number of rows in the scaled image.</p>
</dd>
</dl>
</section>
</section>
<section id="magickshearimage">
<h1><a class="toc-backref" href="#id702">MagickShearImage</a></h1>
<section id="id437">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickShearImage( MagickWand *wand, const PixelWand *background,
                               const double x_shear, onst double y_shear );</pre>
</section>
<section id="id438">
<h2>Description</h2>
<p>MagickShearImage() slides one edge of an image along the X or Y axis,
creating a parallelogram.  An X direction shear slides an edge along the X
axis, while a Y direction shear slides an edge along the Y axis.  The amount
of the shear is controlled by a shear angle.  For X direction shears, x_shear
is measured relative to the Y axis, and similarly, for Y direction shears
y_shear is measured relative to the X axis.  Empty triangles left over from
shearing the image are filled with the background color.</p>
<p>The format of the MagickShearImage method is:</p>
<pre class="literal-block">unsigned int MagickShearImage( MagickWand *wand, const PixelWand *background,
                               const double x_shear, onst double y_shear );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>background:</dt>
<dd><p>The background pixel wand.</p>
</dd>
<dt>x_shear:</dt>
<dd><p>The number of degrees to shear the image.</p>
</dd>
<dt>y_shear:</dt>
<dd><p>The number of degrees to shear the image.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksolarizeimage">
<h1><a class="toc-backref" href="#id703">MagickSolarizeImage</a></h1>
<section id="id439">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSolarizeImage( MagickWand *wand, const double threshold );</pre>
</section>
<section id="id440">
<h2>Description</h2>
<p>MagickSolarizeImage() applies a special effect to the image, similar to the
effect achieved in a photo darkroom by selectively exposing areas of photo
sensitive paper to light.  Threshold ranges from 0 to MaxRGB and is a
measure of the extent of the solarization.</p>
<p>The format of the MagickSolarizeImage method is:</p>
<pre class="literal-block">unsigned int MagickSolarizeImage( MagickWand *wand, const double threshold );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>threshold:</dt>
<dd><p>Define the extent of the solarization.</p>
</dd>
</dl>
</section>
</section>
<section id="magickspreadimage">
<h1><a class="toc-backref" href="#id704">MagickSpreadImage</a></h1>
<section id="id441">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSpreadImage( MagickWand *wand, const double radius );</pre>
</section>
<section id="id442">
<h2>Description</h2>
<p>MagickSpreadImage() is a special effects method that randomly displaces each
pixel in a block defined by the radius parameter.</p>
<p>The format of the MagickSpreadImage method is:</p>
<pre class="literal-block">unsigned int MagickSpreadImage( MagickWand *wand, const double radius );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>radius:</dt>
<dd><p>Choose a random pixel in a neighborhood of this extent.</p>
</dd>
</dl>
</section>
</section>
<section id="magicksteganoimage">
<h1><a class="toc-backref" href="#id705">MagickSteganoImage</a></h1>
<section id="id443">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand *MagickSteganoImage( MagickWand *wand, const MagickWand *watermark_wand,
                                const long offset );</pre>
</section>
<section id="id444">
<h2>Description</h2>
<p>Use MagickSteganoImage() to hide a digital watermark within the image.
Recover the hidden watermark later to prove that the authenticity of
an image.  Offset defines the start position within the image to hide
the watermark.</p>
<p>The format of the MagickSteganoImage method is:</p>
<pre class="literal-block">MagickWand *MagickSteganoImage( MagickWand *wand, const MagickWand *watermark_wand,
                                const long offset );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>watermark_wand:</dt>
<dd><p>The watermark wand.</p>
</dd>
<dt>offset:</dt>
<dd><p>Start hiding at this offset into the image.</p>
</dd>
</dl>
</section>
</section>
<section id="magickstereoimage">
<h1><a class="toc-backref" href="#id706">MagickStereoImage</a></h1>
<section id="id445">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand *MagickStereoImage( MagickWand *wand, const MagickWand *offset_wand );</pre>
</section>
<section id="id446">
<h2>Description</h2>
<p>MagickStereoImage() composites two images and produces a single image that
is the composite of a left and right image of a stereo pair</p>
<p>The format of the MagickStereoImage method is:</p>
<pre class="literal-block">MagickWand *MagickStereoImage( MagickWand *wand, const MagickWand *offset_wand );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>offset_wand:</dt>
<dd><p>Another image wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickstripimage">
<h1><a class="toc-backref" href="#id707">MagickStripImage</a></h1>
<section id="id447">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickStripImage( MagickWand *wand );</pre>
</section>
<section id="id448">
<h2>Description</h2>
<p>MagickStripImage() removes all profiles and text attributes from the image.</p>
<p>The format of the MagickStripImage method is:</p>
<pre class="literal-block">unsigned int MagickStripImage( MagickWand *wand );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickswirlimage">
<h1><a class="toc-backref" href="#id708">MagickSwirlImage</a></h1>
<section id="id449">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickSwirlImage( MagickWand *wand, const double degrees );</pre>
</section>
<section id="id450">
<h2>Description</h2>
<p>MagickSwirlImage() swirls the pixels about the center of the image, where
degrees indicates the sweep of the arc through which each pixel is moved.
You get a more dramatic effect as the degrees move from 1 to 360.</p>
<p>The format of the MagickSwirlImage method is:</p>
<pre class="literal-block">unsigned int MagickSwirlImage( MagickWand *wand, const double degrees );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>degrees:</dt>
<dd><p>Define the tightness of the swirling effect.</p>
</dd>
</dl>
</section>
</section>
<section id="magicktextureimage">
<h1><a class="toc-backref" href="#id709">MagickTextureImage</a></h1>
<section id="id451">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand *MagickTextureImage( MagickWand *wand, const MagickWand *texture_wand );</pre>
</section>
<section id="id452">
<h2>Description</h2>
<p>MagickTextureImage() repeatedly tiles the texture image across and down the
image canvas.</p>
<p>The format of the MagickTextureImage method is:</p>
<pre class="literal-block">MagickWand *MagickTextureImage( MagickWand *wand, const MagickWand *texture_wand );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>texture_wand:</dt>
<dd><p>The texture wand</p>
</dd>
</dl>
</section>
</section>
<section id="magickthresholdimage">
<h1><a class="toc-backref" href="#id710">MagickThresholdImage</a></h1>
<section id="id453">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickThresholdImage( MagickWand *wand, const double threshold );</pre>
</section>
<section id="id454">
<h2>Description</h2>
<p>MagickThresholdImage() changes the value of individual pixels based on
the intensity of each pixel compared to threshold.  The result is a
high-contrast, two color image.</p>
<p>The format of the MagickThresholdImage method is:</p>
<pre class="literal-block">unsigned int MagickThresholdImage( MagickWand *wand, const double threshold );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>threshold:</dt>
<dd><p>Define the threshold value.</p>
</dd>
</dl>
</section>
</section>
<section id="magickthresholdimagechannel">
<h1><a class="toc-backref" href="#id711">MagickThresholdImageChannel</a></h1>
<section id="id455">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickThresholdImageChannel( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel,
                                          const double threshold );</pre>
</section>
<section id="id456">
<h2>Description</h2>
<p>MagickThresholdImageChannel() changes the value of individual pixel
component based on the intensity of each pixel compared to threshold.  The
result is a high-contrast, two color image.</p>
<p>The format of the MagickThresholdImage method is:</p>
<pre class="literal-block">unsigned int MagickThresholdImageChannel( MagickWand *wand, const <a class="reference external" href="../api/types.html#channeltype">ChannelType</a> channel,
                                          const double threshold );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>channel:</dt>
<dd><p>The channel.</p>
</dd>
<dt>threshold:</dt>
<dd><p>Define the threshold value.</p>
</dd>
</dl>
</section>
</section>
<section id="magicktintimage">
<h1><a class="toc-backref" href="#id712">MagickTintImage</a></h1>
<section id="id457">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickTintImage( MagickWand *wand, const PixelWand *tint,
                              const PixelWand *opacity );</pre>
</section>
<section id="id458">
<h2>Description</h2>
<p>MagickTintImage() applies a color vector to each pixel in the image.  The
length of the vector is 0 for black and white and at its maximum for the
midtones.  The vector weighting function is
f(x)=(1-(4.0*((x-0.5)*(x-0.5)))).</p>
<p>The format of the MagickTintImage method is:</p>
<pre class="literal-block">unsigned int MagickTintImage( MagickWand *wand, const PixelWand *tint,
                              const PixelWand *opacity );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>tint:</dt>
<dd><p>The tint pixel wand.</p>
</dd>
<dt>opacity:</dt>
<dd><p>The opacity pixel wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magicktransformimage">
<h1><a class="toc-backref" href="#id713">MagickTransformImage</a></h1>
<section id="id459">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand *MagickTransformImage( MagickWand *wand, const char *crop,
                                  const char *geometry );</pre>
</section>
<section id="id460">
<h2>Description</h2>
<p>MagickTransformImage() is a convenience method that behaves like
MagickResizeImage() or MagickCropImage() but accepts scaling and/or cropping
information as a region geometry specification.  If the operation fails, the
original image handle is returned.</p>
<p>The format of the MagickTransformImage method is:</p>
<pre class="literal-block">MagickWand *MagickTransformImage( MagickWand *wand, const char *crop,
                                  const char *geometry );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>crop:</dt>
<dd><p>A crop geometry string.  This geometry defines a subregion of the
image to crop.</p>
</dd>
<dt>geometry:</dt>
<dd><p>An image geometry string.  This geometry defines the final
size of the image.</p>
</dd>
</dl>
</section>
</section>
<section id="magicktransparentimage">
<h1><a class="toc-backref" href="#id714">MagickTransparentImage</a></h1>
<section id="id461">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickTransparentImage( MagickWand *wand, const PixelWand *target,
                                     const unsigned int opacity, const double fuzz );</pre>
</section>
<section id="id462">
<h2>Description</h2>
<p>MagickTransparentImage() changes any pixel that matches color with the color
defined by fill.</p>
<p>The format of the MagickTransparentImage method is:</p>
<pre class="literal-block">unsigned int MagickTransparentImage( MagickWand *wand, const PixelWand *target,
                                     const unsigned int opacity, const double fuzz );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>target:</dt>
<dd><p>Change this target color to specified opacity value within
the image.</p>
</dd>
<dt>opacity:</dt>
<dd><p>The replacement opacity value.</p>
</dd>
<dt>fuzz:</dt>
<dd><p>By default target must match a particular pixel color
exactly.  However, in many cases two colors may differ by a small amount.
The fuzz member of image defines how much tolerance is acceptable to
consider two colors as the same.  For example, set fuzz to 10 and the
color red at intensities of 100 and 102 respectively are now interpreted
as the same color for the purposes of the floodfill.</p>
</dd>
</dl>
</section>
</section>
<section id="magicktrimimage">
<h1><a class="toc-backref" href="#id715">MagickTrimImage</a></h1>
<section id="id463">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickTrimImage( MagickWand *wand, const double fuzz );</pre>
</section>
<section id="id464">
<h2>Description</h2>
<p>MagickTrimImage() remove edges that are the background color from the image.</p>
<p>The format of the MagickTrimImage method is:</p>
<pre class="literal-block">unsigned int MagickTrimImage( MagickWand *wand, const double fuzz );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>fuzz:</dt>
<dd><p>By default target must match a particular pixel color
exactly.  However, in many cases two colors may differ by a small amount.
The fuzz member of image defines how much tolerance is acceptable to
consider two colors as the same.  For example, set fuzz to 10 and the
color red at intensities of 100 and 102 respectively are now interpreted
as the same color for the purposes of the floodfill.</p>
</dd>
</dl>
</section>
</section>
<section id="magickunsharpmaskimage">
<h1><a class="toc-backref" href="#id716">MagickUnsharpMaskImage</a></h1>
<section id="id465">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickUnsharpMaskImage( MagickWand *wand, const double radius, const double sigma,
                                     const double amount, const double threshold );</pre>
</section>
<section id="id466">
<h2>Description</h2>
<p>MagickUnsharpMaskImage() sharpens an image.  We convolve the image with a
Gaussian operator of the given radius and standard deviation (sigma).
For reasonable results, radius should be larger than sigma.  Use a radius
of 0 and UnsharpMaskImage() selects a suitable radius for you.</p>
<p>The format of the MagickUnsharpMaskImage method is:</p>
<pre class="literal-block">unsigned int MagickUnsharpMaskImage( MagickWand *wand, const double radius, const double sigma,
                                     const double amount, const double threshold );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>radius:</dt>
<dd><p>The radius of the Gaussian, in pixels, not counting the center
pixel.</p>
</dd>
<dt>sigma:</dt>
<dd><p>The standard deviation of the Gaussian, in pixels.</p>
</dd>
<dt>amount:</dt>
<dd><p>The percentage of the difference between the original and the
blur image that is added back into the original.</p>
</dd>
<dt>threshold:</dt>
<dd><p>The threshold in pixels needed to apply the diffence amount.</p>
</dd>
</dl>
</section>
</section>
<section id="magickwaveimage">
<h1><a class="toc-backref" href="#id717">MagickWaveImage</a></h1>
<section id="id467">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickWaveImage( MagickWand *wand, const double amplitude,
                              const double wave_length );</pre>
</section>
<section id="id468">
<h2>Description</h2>
<p>MagickWaveImage()  creates a &quot;ripple&quot; effect in the image by shifting
the pixels vertically along a sine wave whose amplitude and wavelength
is specified by the given parameters.</p>
<p>The format of the MagickWaveImage method is:</p>
<pre class="literal-block">unsigned int MagickWaveImage( MagickWand *wand, const double amplitude,
                              const double wave_length );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>amplitude, wave_length:</dt>
<dd><p>Define the amplitude and wave length of the
sine wave.</p>
</dd>
</dl>
</section>
</section>
<section id="magickwhitethresholdimage">
<h1><a class="toc-backref" href="#id718">MagickWhiteThresholdImage</a></h1>
<section id="id469">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickWhiteThresholdImage( MagickWand *wand, const PixelWand *threshold );</pre>
</section>
<section id="id470">
<h2>Description</h2>
<p>MagickWhiteThresholdImage() is like ThresholdImage() but  forces all pixels
above the threshold into white while leaving all pixels below the threshold
unchanged.</p>
<p>The format of the MagickWhiteThresholdImage method is:</p>
<pre class="literal-block">unsigned int MagickWhiteThresholdImage( MagickWand *wand, const PixelWand *threshold );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>threshold:</dt>
<dd><p>The pixel wand.</p>
</dd>
</dl>
</section>
</section>
<section id="magickwriteimage">
<h1><a class="toc-backref" href="#id719">MagickWriteImage</a></h1>
<section id="id471">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickWriteImage( MagickWand *wand, const char *filename );</pre>
</section>
<section id="id472">
<h2>Description</h2>
<p>MagickWriteImage() writes an image.</p>
<p>The format of the MagickWriteImage method is:</p>
<pre class="literal-block">unsigned int MagickWriteImage( MagickWand *wand, const char *filename );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>filename:</dt>
<dd><p>The image filename.</p>
</dd>
</dl>
</section>
</section>
<section id="magickwriteimagesfile">
<h1><a class="toc-backref" href="#id720">MagickWriteImagesFile</a></h1>
<section id="id473">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickWriteImagesFile( MagickWand *wand, FILE *file, const unsigned int adjoin );</pre>
</section>
<section id="id474">
<h2>Description</h2>
<p>MagickWriteImagesFile() writes an image or image sequence to a stdio
FILE handle.  This may be used to append an encoded image to an already
existing appended image sequence if the file seek position is at the end
of an existing file.</p>
<p>The format of the MagickWriteImages method is:</p>
<pre class="literal-block">unsigned int MagickWriteImagesFile( MagickWand *wand, FILE *file, const unsigned int adjoin );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>file:</dt>
<dd><p>The open (and positioned) file handle.</p>
</dd>
<dt>adjoin:</dt>
<dd><p>join images into a single multi-image file.</p>
</dd>
</dl>
</section>
</section>
<section id="magickwriteimageblob">
<h1><a class="toc-backref" href="#id721">MagickWriteImageBlob</a></h1>
<section id="id475">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned char *MagickWriteImageBlob( MagickWand *wand, size_t *length );</pre>
</section>
<section id="id476">
<h2>Description</h2>
<p>MagickWriteImageBlob() implements direct to memory image formats.  It
returns the image as a blob (a formatted &quot;file&quot; in memory) and its
length, starting from the current position in the image sequence.
Use MagickSetImageFormat() to set the format to write to the blob
(GIF, JPEG,  PNG, etc.).</p>
<p>Use MagickResetIterator() on the wand if it is desired to write
a sequence from the beginning and the iterator is not currently
at the beginning.</p>
<p>The format of the MagickWriteImageBlob method is:</p>
<pre class="literal-block">unsigned char *MagickWriteImageBlob( MagickWand *wand, size_t *length );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>length:</dt>
<dd><p>The length of the blob.</p>
</dd>
</dl>
</section>
</section>
<section id="magickwriteimagefile">
<h1><a class="toc-backref" href="#id722">MagickWriteImageFile</a></h1>
<section id="id477">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickWriteImageFile( MagickWand *wand, FILE *file );</pre>
</section>
<section id="id478">
<h2>Description</h2>
<p>MagickWriteImageFile() writes an image to an open file descriptor.</p>
<p>The format of the MagickWandToFile method is:</p>
<pre class="literal-block">unsigned int MagickWriteImageFile( MagickWand *wand, FILE *file );</pre>
<p>A description of each parameter follows:</p>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>file:</dt>
<dd><p>The file descriptor.</p>
</dd>
</dl>
</section>
</section>
<section id="magickwriteimages">
<h1><a class="toc-backref" href="#id723">MagickWriteImages</a></h1>
<section id="id479">
<h2>Synopsis</h2>
<pre class="literal-block">unsigned int MagickWriteImages( MagickWand *wand, const char *filename,
                                const unsigned int adjoin );</pre>
</section>
<section id="id480">
<h2>Description</h2>
<p>MagickWriteImages() writes an image or image sequence.  If the wand
represents an image sequence, then it is written starting at the first
frame in the sequence.</p>
<p>The format of the MagickWriteImages method is:</p>
<pre class="literal-block">unsigned int MagickWriteImages( MagickWand *wand, const char *filename,
                                const unsigned int adjoin );</pre>
<dl class="simple">
<dt>wand:</dt>
<dd><p>The magick wand.</p>
</dd>
<dt>filename:</dt>
<dd><p>The image filename.</p>
</dd>
<dt>adjoin:</dt>
<dd><p>join images into a single multi-image file.</p>
</dd>
</dl>
</section>
</section>
<section id="newmagickwand">
<h1><a class="toc-backref" href="#id724">NewMagickWand</a></h1>
<section id="id481">
<h2>Synopsis</h2>
<pre class="literal-block">MagickWand NewMagickWand( void );</pre>
</section>
<section id="id482">
<h2>Description</h2>
<p>NewMagickWand() returns a wand required for all other methods in the API.</p>
<p>The format of the NewMagickWand method is:</p>
<pre class="literal-block">MagickWand NewMagickWand( void );</pre>
</section>
</section>
</main>


<hr class="docutils">
<div class="document">
    <p><a href="../Copyright.html">Copyright</a> © GraphicsMagick Group 2002-2025<!--SPONSOR_LOGO--></p>
</div>

</main>
</body>
</html>
